@agentxm/workspace-state 0.28.4-bootstrap.0

package/dist/src/workspace/read-model/scanners/agent-dir.js

@@ -0,0 +1,180 @@
+/**
+ * Agent-directory scanner: enumerates per-agent skill and subagent
+ * directories declared by the existing `AgentRegistry`. Each occurrence
+ * carries an `agent-dir` discriminator parameterized by `agentId` and the
+ * subject `type`.
+ *
+ * Subject coverage in v1:
+ *
+ * - skill — every agent with a non-empty `agent.skills.dir`.
+ * - subagent — every agent with `agent.subagents?.dir`. Single-file
+ *   subagent surfaces (`isFile === true`, e.g., `roo`'s `.roomodes`) emit one
+ *   occurrence per file path; the file itself is the materialization.
+ *
+ * Rules: no agent in the v1 `AgentRegistry` exposes a rules directory, so the
+ * scanner emits no rule occurrences.
+ *
+ * Each occurrence carries structural fields the subject modules need for
+ * cross-platform path handling — `pathSegments` (the absolute path split via
+ * the `Path` service) and `subjectFile` (the canonical primary file inside
+ * the subject directory) — plus a probed `subjectFileExists` flag so subject
+ * modules do not hardcode presence.
+ *
+ * Per Decision 5, scanner output is occurrence-shaped. The public effect
+ * carries no `FileSystem | Path` requirement; per-file partial failures
+ * publish diagnostic warnings rather than failing the cell.
+ *
+ * The scanner avoids `fs.stat` and uses only `fs.exists` / `fs.readDirectory`
+ * so it remains compatible with the fixture builder's in-memory `FileSystem`.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { AGENTS } from "@agentxm/extension-model/unstable/agents/registry";
+import { makeAbsolutePath } from "@agentxm/extension-model/unstable/path-types";
+import { childEntries, fileExists, filterDirectories, splitAbsolutePathSegments, } from "./fs-helpers.js";
+const SCANNER_NAME = "agent-dir";
+const normalizeFileBackedName = (name) => {
+    const normalized = name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 64)
+        .replace(/-+$/g, "");
+    return normalized === "" ? "unnamed" : normalized;
+};
+/**
+ * Closure helper: returns the dependency-closed scanner effect.
+ */
+export const makeAgentDirScanner = (deps) => scanAgentDirs(deps);
+const subjectsForAgent = (descriptor) => {
+    const out = [];
+    if (descriptor.skills !== undefined) {
+        if (descriptor.skills.dir.length > 0) {
+            out.push({
+                type: "skill",
+                relativeDir: descriptor.skills.dir,
+                isFile: false,
+                readPathStatus: "primary",
+            });
+        }
+        for (const { path, status } of descriptor.skills.additionalReadPaths) {
+            out.push({ type: "skill", relativeDir: path, isFile: false, readPathStatus: status });
+        }
+    }
+    if (descriptor.subagents !== undefined) {
+        out.push({
+            type: "subagent",
+            relativeDir: descriptor.subagents.dir,
+            isFile: descriptor.subagents.isFile === true,
+        });
+    }
+    return out;
+};
+/**
+ * Map a directory-style subject + name to the canonical primary file inside
+ * its `<dir>/<name>/` content root. Mirrors the convention used by the
+ * canonical-extensions scanner.
+ *
+ * - `skill` → `SKILL.md` (fixed)
+ */
+const subjectFileNameFor = () => "SKILL.md";
+/**
+ * Skills use one subdirectory per subject. Subagents use the flat files AXM's
+ * agent renderers produce.
+ *
+ * For each occurrence, probe the canonical subject file (e.g., `SKILL.md`)
+ * via `fs.exists` so subject modules can consume `subjectFileExists` rather
+ * than re-checking presence themselves.
+ */
+const scanSubjectDirectory = (deps, agentId, subject) => Effect.gen(function* () {
+    const { fs, path, scope, workspaceRoot, diagnostics } = deps;
+    const subjectAbsolute = path.join(workspaceRoot, subject.relativeDir);
+    if (subject.isFile) {
+        const present = yield* fileExists(SCANNER_NAME, fs, diagnostics, subjectAbsolute);
+        if (!present)
+            return [];
+        const contentLocation = makeAbsolutePath(path, subjectAbsolute);
+        const occurrence = {
+            _tag: "agent-dir",
+            scope,
+            type: subject.type,
+            agentId,
+            ...(subject.readPathStatus === undefined ? {} : { readPathStatus: subject.readPathStatus }),
+            name: normalizeFileBackedName(path.basename(subjectAbsolute)),
+            contentLocation,
+            pathSegments: splitAbsolutePathSegments(path, subjectAbsolute),
+            // Single-file surfaces ARE the materialization; the file itself is
+            // the subject file and presence has already been confirmed.
+            subjectFile: Option.some(contentLocation),
+            subjectFileExists: true,
+        };
+        return [occurrence];
+    }
+    const candidates = yield* childEntries(SCANNER_NAME, fs, diagnostics, path, subjectAbsolute);
+    const nameDirs = yield* filterDirectories(fs, candidates);
+    if (subject.type === "skill") {
+        return yield* Effect.forEach(nameDirs, (nameDir) => Effect.gen(function* () {
+            const name = path.basename(nameDir);
+            const subjectFilePath = path.join(nameDir, subjectFileNameFor());
+            const subjectFileExists = yield* fileExists(SCANNER_NAME, fs, diagnostics, subjectFilePath);
+            const contentLocation = makeAbsolutePath(path, nameDir);
+            return {
+                _tag: "agent-dir",
+                scope,
+                type: subject.type,
+                agentId,
+                ...(subject.readPathStatus === undefined
+                    ? {}
+                    : { readPathStatus: subject.readPathStatus }),
+                name,
+                contentLocation,
+                pathSegments: splitAbsolutePathSegments(path, nameDir),
+                subjectFile: Option.some(makeAbsolutePath(path, subjectFilePath)),
+                subjectFileExists,
+            };
+        }), { concurrency: "unbounded" });
+    }
+    const supportedExtensions = [".md", ".json", ".toml"];
+    const directorySet = new Set(nameDirs);
+    const fileOccurrences = yield* Effect.forEach(candidates, (candidate) => Effect.gen(function* () {
+        if (directorySet.has(candidate))
+            return Option.none();
+        const extension = path.extname(candidate).toLowerCase();
+        if (!supportedExtensions.includes(extension)) {
+            return Option.none();
+        }
+        const readable = yield* Effect.result(fs.readFile(candidate));
+        if (readable._tag === "Failure")
+            return Option.none();
+        const fileName = path.basename(candidate);
+        const name = normalizeFileBackedName(fileName.slice(0, -extension.length));
+        const contentLocation = makeAbsolutePath(path, candidate);
+        return Option.some({
+            _tag: "agent-dir",
+            scope,
+            type: subject.type,
+            agentId,
+            ...(subject.readPathStatus === undefined
+                ? {}
+                : { readPathStatus: subject.readPathStatus }),
+            name,
+            contentLocation,
+            pathSegments: splitAbsolutePathSegments(path, candidate),
+            subjectFile: Option.some(contentLocation),
+            subjectFileExists: true,
+        });
+    }), { concurrency: "unbounded" });
+    return fileOccurrences.flatMap(Option.toArray);
+});
+// ---------------------------------------------------------------------------
+// Scanner body
+// ---------------------------------------------------------------------------
+const scanAgentDirs = Effect.fn("workspace.read-model.scanner.agent-dir")(function* (deps) {
+    const registry = deps.agentRegistry ?? AGENTS;
+    const occurrences = yield* Effect.forEach(Object.values(registry), (descriptor) => {
+        const subjects = subjectsForAgent(descriptor);
+        return Effect.forEach(subjects, (subject) => scanSubjectDirectory(deps, descriptor.id, subject), { concurrency: "unbounded" }).pipe(Effect.map((results) => results.flat()));
+    }, { concurrency: "unbounded" });
+    return occurrences.flat();
+});
+//# sourceMappingURL=agent-dir.js.map

package/dist/src/workspace/read-model/scanners/agent-root.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Shared agent-root resolution.
+ *
+ * `agent-settings.ts` and `mcp-config.ts` both need to resolve a per-agent
+ * root directory (e.g., `.claude` for `claude-code`, `.cursor` for `cursor`)
+ * to compose agent-specific config paths (`<rootDir>/settings.json`,
+ * `<rootDir>/mcp.json`).
+ *
+ * Resolution rules (with `exactOptionalPropertyTypes: true`, the descriptor
+ * shape `rootDir?: string | undefined` distinguishes three states):
+ *
+ * 1. `descriptor.rootDir` is a `string` — use it directly.
+ * 2. `descriptor.rootDir` is explicitly `undefined` (key present but
+ *    nullish) — the agent has opted out of native-config scanning. Return
+ *    `Option.none()` and the scanners SHALL skip this agent.
+ * 3. `descriptor.rootDir` is omitted entirely — use the first segment of
+ *    `descriptor.skills.dir` when the Skill surface exists. This handles
+ *    platform-native separators and collapses `.` segments through the Path
+ *    service's normalization.
+ * 4. If there is no Skill surface, or the heuristic produces nothing, fall
+ *    back to `.${descriptor.id}`.
+ *
+ * The heuristic-fallback path emits a one-time `scanner-config` diagnostic
+ * warning per scanner instance per agent so agent maintainers see a nudge
+ * to set `rootDir` explicitly. Collisions detected at construction time
+ * also warn through the same `scanner-config` code.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import type * as Path from "effect/Path";
+import type { AgentDescriptor } from "@agentxm/extension-model/unstable/agents/types";
+import type { Diagnostics } from "../diagnostics.js";
+/**
+ * Per-instance state shared across the scanners that resolve agent roots.
+ * Both `mcp-config` and `agent-settings` share one tracker so a single
+ * heuristic-fallback warning per agent fires across both scanners (rather
+ * than once each).
+ *
+ * Construction is cheap: a `Set<string>` allocated by the live layer and
+ * passed to both scanners.
+ */
+export interface AgentRootResolverState {
+    readonly heuristicWarned: Set<string>;
+}
+export declare const makeAgentRootResolverState: () => AgentRootResolverState;
+/**
+ * Resolve the per-agent root directory for one descriptor. Returns
+ * `Option.none()` when the agent has explicitly opted out of native-config
+ * scanning (descriptor's `rootDir` is `undefined`); returns
+ * `Option.some(segment)` otherwise.
+ *
+ * The result is intentionally a relative segment, not an absolute path:
+ * each caller resolves the per-file path differently (`mcp.json` vs
+ * `settings.json`), and the join concern stays at the call site.
+ */
+export declare const agentRootSegment: (path: Path.Path, descriptor: AgentDescriptor, diagnostics: Diagnostics, state: AgentRootResolverState) => Effect.Effect<Option.Option<string>>;
+/**
+ * Detect cases where two or more registry descriptors resolve to the same
+ * `agentRootSegment`. The detection runs once at construction time (per
+ * `WorkspaceReadModelLive` instance); each collision emits a
+ * `scanner-config` diagnostic warning. The function does NOT throw and
+ * does NOT skip scanning — callers continue to scan; the warning is the
+ * signal.
+ *
+ * The check uses the same resolution rules as `agentRootSegment` but
+ * inlined to avoid producing fallback warnings during collision checking
+ * (the heuristic-fallback warning fires once per agent on first scanner
+ * use; running it during collision detection would race with normal
+ * scanner emission). Agents that opt out (`rootDir: undefined`) are
+ * excluded from collision checking entirely.
+ */
+export declare const detectAgentRootCollisions: (path: Path.Path, descriptors: ReadonlyArray<AgentDescriptor>, diagnostics: Diagnostics) => Effect.Effect<void>;
+//# sourceMappingURL=agent-root.d.ts.map

package/dist/src/workspace/read-model/scanners/agent-root.js

@@ -0,0 +1,148 @@
+/**
+ * Shared agent-root resolution.
+ *
+ * `agent-settings.ts` and `mcp-config.ts` both need to resolve a per-agent
+ * root directory (e.g., `.claude` for `claude-code`, `.cursor` for `cursor`)
+ * to compose agent-specific config paths (`<rootDir>/settings.json`,
+ * `<rootDir>/mcp.json`).
+ *
+ * Resolution rules (with `exactOptionalPropertyTypes: true`, the descriptor
+ * shape `rootDir?: string | undefined` distinguishes three states):
+ *
+ * 1. `descriptor.rootDir` is a `string` — use it directly.
+ * 2. `descriptor.rootDir` is explicitly `undefined` (key present but
+ *    nullish) — the agent has opted out of native-config scanning. Return
+ *    `Option.none()` and the scanners SHALL skip this agent.
+ * 3. `descriptor.rootDir` is omitted entirely — use the first segment of
+ *    `descriptor.skills.dir` when the Skill surface exists. This handles
+ *    platform-native separators and collapses `.` segments through the Path
+ *    service's normalization.
+ * 4. If there is no Skill surface, or the heuristic produces nothing, fall
+ *    back to `.${descriptor.id}`.
+ *
+ * The heuristic-fallback path emits a one-time `scanner-config` diagnostic
+ * warning per scanner instance per agent so agent maintainers see a nudge
+ * to set `rootDir` explicitly. Collisions detected at construction time
+ * also warn through the same `scanner-config` code.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+export const makeAgentRootResolverState = () => ({
+    heuristicWarned: new Set(),
+});
+// ---------------------------------------------------------------------------
+// Public resolver
+// ---------------------------------------------------------------------------
+/**
+ * Resolve the per-agent root directory for one descriptor. Returns
+ * `Option.none()` when the agent has explicitly opted out of native-config
+ * scanning (descriptor's `rootDir` is `undefined`); returns
+ * `Option.some(segment)` otherwise.
+ *
+ * The result is intentionally a relative segment, not an absolute path:
+ * each caller resolves the per-file path differently (`mcp.json` vs
+ * `settings.json`), and the join concern stays at the call site.
+ */
+export const agentRootSegment = (path, descriptor, diagnostics, state) => {
+    // 1. Explicit `string` rootDir wins.
+    if (typeof descriptor.rootDir === "string") {
+        return Effect.succeed(Option.some(descriptor.rootDir));
+    }
+    // 2. The descriptor key is present and set to `undefined` — explicit
+    // opt-out. With `exactOptionalPropertyTypes: true`, this is
+    // distinguishable from key omission via the runtime `in` check.
+    if ("rootDir" in descriptor && descriptor.rootDir === undefined) {
+        return Effect.succeed(Option.none());
+    }
+    // 3. Heuristic fallback. Emit a one-time scanner-config warning per
+    // agent so maintainers see the nudge to confirm `rootDir`.
+    return Effect.gen(function* () {
+        if (!state.heuristicWarned.has(descriptor.id)) {
+            state.heuristicWarned.add(descriptor.id);
+            yield* diagnostics.append({
+                source: "scanner",
+                message: `agent-root: descriptor for "${descriptor.id}" has no rootDir; falling back to its Skill directory or agent id`,
+                code: "scanner-config",
+            });
+        }
+        return Option.some(heuristicSegment(path, descriptor));
+    });
+};
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+const heuristicSegment = (path, descriptor) => {
+    const dir = descriptor.skills?.dir;
+    if (dir === undefined)
+        return `.${descriptor.id}`;
+    if (dir.length === 0)
+        return `.${descriptor.id}`;
+    const segments = splitPathSegments(path, dir);
+    const first = segments[0];
+    if (first === undefined || first.length === 0)
+        return `.${descriptor.id}`;
+    return first;
+};
+/**
+ * Split a path into its constituent segments using the Path service. Honors
+ * the platform separator and skips empty segments produced by leading or
+ * duplicate separators.
+ */
+const splitPathSegments = (path, value) => {
+    // Normalize first so `.` and `..` segments collapse the way the platform
+    // expects, then split on the platform separator. Path.normalize preserves
+    // a trailing separator only if one was present, which we drop by filtering
+    // out empty segments.
+    const normalized = path.normalize(value);
+    return normalized.split(path.sep).filter((segment) => segment.length > 0);
+};
+// ---------------------------------------------------------------------------
+// Collision detection (called at scanner-set construction time)
+// ---------------------------------------------------------------------------
+/**
+ * Detect cases where two or more registry descriptors resolve to the same
+ * `agentRootSegment`. The detection runs once at construction time (per
+ * `WorkspaceReadModelLive` instance); each collision emits a
+ * `scanner-config` diagnostic warning. The function does NOT throw and
+ * does NOT skip scanning — callers continue to scan; the warning is the
+ * signal.
+ *
+ * The check uses the same resolution rules as `agentRootSegment` but
+ * inlined to avoid producing fallback warnings during collision checking
+ * (the heuristic-fallback warning fires once per agent on first scanner
+ * use; running it during collision detection would race with normal
+ * scanner emission). Agents that opt out (`rootDir: undefined`) are
+ * excluded from collision checking entirely.
+ */
+export const detectAgentRootCollisions = (path, descriptors, diagnostics) => Effect.gen(function* () {
+    const buckets = new Map();
+    for (const descriptor of descriptors) {
+        const segment = resolveCollisionSegment(path, descriptor);
+        if (Option.isNone(segment))
+            continue;
+        const existing = buckets.get(segment.value);
+        if (existing === undefined) {
+            buckets.set(segment.value, [descriptor.id]);
+        }
+        else {
+            existing.push(descriptor.id);
+        }
+    }
+    for (const [segment, ids] of buckets) {
+        if (ids.length < 2)
+            continue;
+        yield* diagnostics.append({
+            source: "scanner",
+            message: `agent-root: collision on "${segment}" across agents: ${ids.join(", ")}`,
+            code: "scanner-config",
+        });
+    }
+});
+const resolveCollisionSegment = (path, descriptor) => {
+    if (typeof descriptor.rootDir === "string")
+        return Option.some(descriptor.rootDir);
+    if ("rootDir" in descriptor && descriptor.rootDir === undefined)
+        return Option.none();
+    return Option.some(heuristicSegment(path, descriptor));
+};
+//# sourceMappingURL=agent-root.js.map

package/dist/src/workspace/read-model/scanners/agent-settings.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Agent-settings scanner: enumerates per-agent native settings files (e.g.,
+ * `.claude/settings.json`, `.cursor/settings.json`).
+ *
+ * Per Decision 5, scanner output is occurrence-shaped. Each occurrence
+ * represents one observable settings file — present and readable on disk —
+ * keyed by `agentId`. The per-file payload is intentionally not parsed here:
+ * Phase 8's per-agent modules decode the typed `nativeConfig` shape through
+ * their own schemas. The scanner's contract is "this agent has a settings
+ * file at this absolute path", not "this settings file is well-formed".
+ *
+ * Per-file partial failures (e.g., unreadable directory) become diagnostic
+ * warnings rather than errors. The error channel stays empty.
+ */
+import * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import type * as Path from "effect/Path";
+import type { AgentDescriptor, AgentId } from "@agentxm/extension-model/unstable/agents/types";
+import type { Diagnostics } from "../diagnostics.js";
+import type { Scope } from "../types.js";
+import { type AgentRootResolverState } from "./agent-root.js";
+import type { AgentSettingsOccurrence } from "./types.js";
+/**
+ * Inputs the live layer captures before invoking the scanner. The optional
+ * `agentRegistry` mirrors the agent-dir scanner. `rootResolverState` lets
+ * the live layer share heuristic-warning state across `mcp-config` and
+ * `agent-settings`; when omitted, a fresh state is used (one warning per
+ * scanner invocation per agent).
+ */
+export interface AgentSettingsScannerDeps {
+    readonly fs: FileSystem.FileSystem;
+    readonly path: Path.Path;
+    readonly workspaceRoot: string;
+    readonly scope: Scope;
+    readonly diagnostics: Diagnostics;
+    readonly agentRegistry?: Readonly<Record<AgentId, AgentDescriptor>>;
+    readonly rootResolverState?: AgentRootResolverState;
+}
+/**
+ * Closure helper: returns the dependency-closed scanner effect.
+ */
+export declare const makeAgentSettingsScanner: (deps: AgentSettingsScannerDeps) => Effect.Effect<ReadonlyArray<AgentSettingsOccurrence>>;
+//# sourceMappingURL=agent-settings.d.ts.map

package/dist/src/workspace/read-model/scanners/agent-settings.js

@@ -0,0 +1,54 @@
+/**
+ * Agent-settings scanner: enumerates per-agent native settings files (e.g.,
+ * `.claude/settings.json`, `.cursor/settings.json`).
+ *
+ * Per Decision 5, scanner output is occurrence-shaped. Each occurrence
+ * represents one observable settings file — present and readable on disk —
+ * keyed by `agentId`. The per-file payload is intentionally not parsed here:
+ * Phase 8's per-agent modules decode the typed `nativeConfig` shape through
+ * their own schemas. The scanner's contract is "this agent has a settings
+ * file at this absolute path", not "this settings file is well-formed".
+ *
+ * Per-file partial failures (e.g., unreadable directory) become diagnostic
+ * warnings rather than errors. The error channel stays empty.
+ */
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { AGENTS } from "@agentxm/extension-model/unstable/agents/registry";
+import { makeAbsolutePath } from "@agentxm/extension-model/unstable/path-types";
+import { agentRootSegment, makeAgentRootResolverState, } from "./agent-root.js";
+import { fileExists } from "./fs-helpers.js";
+const SCANNER_NAME = "agent-settings";
+/**
+ * Closure helper: returns the dependency-closed scanner effect.
+ */
+export const makeAgentSettingsScanner = (deps) => scanAgentSettings(deps);
+// ---------------------------------------------------------------------------
+// Scanner body
+// ---------------------------------------------------------------------------
+const scanAgentSettings = Effect.fn("workspace.read-model.scanner.agent-settings")(function* (deps) {
+    const { fs, path, workspaceRoot, scope, diagnostics } = deps;
+    const registry = deps.agentRegistry ?? AGENTS;
+    const rootResolverState = deps.rootResolverState ?? makeAgentRootResolverState();
+    const occurrences = yield* Effect.forEach(Object.values(registry), (descriptor) => Effect.gen(function* () {
+        // Resolve the per-agent root segment. `Option.none()` means the
+        // descriptor opts out of native-config scanning — skip it.
+        const rootSegmentOpt = yield* agentRootSegment(path, descriptor, diagnostics, rootResolverState);
+        if (Option.isNone(rootSegmentOpt)) {
+            return Option.none();
+        }
+        const filePath = path.join(workspaceRoot, rootSegmentOpt.value, "settings.json");
+        const present = yield* fileExists(SCANNER_NAME, fs, diagnostics, filePath);
+        if (!present)
+            return Option.none();
+        return Option.some({
+            _tag: "agent-settings",
+            scope,
+            agentId: descriptor.id,
+            contentLocation: makeAbsolutePath(path, filePath),
+        });
+    }), { concurrency: "unbounded" });
+    return Array.getSomes(occurrences);
+});
+//# sourceMappingURL=agent-settings.js.map

package/dist/src/workspace/read-model/scanners/canonical-extensions.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Canonical-extensions scanner: enumerates authored project type roots and
+ * source-qualified acquired packages beneath `agent_extensions/` or the
+ * corresponding user-scope `agent_extensions/` root.
+ *
+ * Per Decision 5 of the workspace read-model design, scanner output is
+ * occurrence-shaped. Each emitted occurrence carries the scanner-tier origin
+ * discriminator (`canonical-axm` | `external-axm`) plus the extension type;
+ * Phase 7 maps these into per-subject origin unions.
+ *
+ * Each occurrence carries structural fields the subject modules need for
+ * cross-platform path handling — `pathSegments` (the absolute path split via
+ * the `Path` service) and `subjectFile` (the canonical primary content file
+ * for the subject type, e.g., `<dir>/SKILL.md` for skills) — plus a probed
+ * `subjectFileExists` flag so subject modules do not hardcode presence.
+ *
+ * Scanner contract:
+ *
+ * - Public effect carries no `FileSystem | Path` requirement. Construction
+ *   takes a deps record and returns an `Effect<ReadonlyArray<…>>`.
+ * - Per-file partial failures (a directory we cannot enumerate) become
+ *   diagnostic warnings, not errors. The error channel stays empty.
+ * - WorkspaceMutations-root path-escape is checked at provider construction (Phase 9),
+ *   not inside the scanner.
+ *
+ * The scanner avoids `fs.stat` and uses only `fs.exists` / `fs.readDirectory`
+ * so it remains compatible with the fixture builder's in-memory `FileSystem`.
+ * "Is this a directory" is decided by whether `readDirectory` returns
+ * successfully; non-directory entries are silently ignored.
+ */
+import * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import type * as Path from "effect/Path";
+import type { Diagnostics } from "../diagnostics.js";
+import type { WorkspaceLayout } from "../../layout.js";
+import type { CanonicalExtensionOccurrence } from "./types.js";
+export interface CanonicalExtensionsScannerDeps {
+    readonly fs: FileSystem.FileSystem;
+    readonly path: Path.Path;
+    readonly workspaceRoot: string;
+    readonly diagnostics: Diagnostics;
+    readonly layout: WorkspaceLayout;
+}
+/**
+ * Closure helper: returns the dependency-closed scanner effect.
+ */
+export declare const makeCanonicalExtensionsScanner: (deps: CanonicalExtensionsScannerDeps) => Effect.Effect<ReadonlyArray<CanonicalExtensionOccurrence>>;
+//# sourceMappingURL=canonical-extensions.d.ts.map