@agentxm/workspace-state 0.28.4-bootstrap.0

package/dist/src/workspace/read-model/scanners/mcp-config.js

@@ -0,0 +1,212 @@
+/**
+ * MCP-config scanner: plans physical targets from the capability catalog,
+ * reads each physical file once, and emits one occurrence per declared server.
+ * Shared targets remain shared observations; agent-native targets retain the
+ * exact agent id whose private surface supplied the observation.
+ *
+ * Per-file partial failures (unreadable config, bad JSON, schema-incompatible
+ * payload) become diagnostic warnings rather than errors. The error channel
+ * stays empty.
+ *
+ * MCP config layout:
+ *
+ * ```json
+ * {
+ *   "mcpServers": {
+ *     "<server-name>": { ... }
+ *   }
+ * }
+ * ```
+ *
+ * The scanner emits one occurrence per `<server-name>` and captures each
+ * record-shaped server payload for import/adoption flows.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { parse } from "jsonc-parser";
+import { getHome } from "../../../utils/environment.js";
+import { AGENTS } from "@agentxm/extension-model/unstable/agents/registry";
+import { CONFIGURABLE_AGENTS_BY_ID, } from "@agentxm/extension-model/unstable/agent-capabilities";
+import { ExtensionNameSchema, } from "@agentxm/extension-model/unstable/extensions/common";
+import { makeAbsolutePath } from "@agentxm/extension-model/unstable/path-types";
+import { isPathSafe } from "../../../utils/path-safety.js";
+const SCANNER_NAME = "mcp-config";
+/**
+ * Closure helper: returns the dependency-closed scanner effect.
+ */
+export const makeMcpConfigScanner = (deps) => scanMcpConfig(deps);
+// ---------------------------------------------------------------------------
+// Helpers: read + parse + extract server names
+// ---------------------------------------------------------------------------
+/**
+ * Minimum shape the scanner needs from an MCP config file: a top-level
+ * object that may contain an agent-configured server record. Per-server payloads stay
+ * opaque (`Schema.Unknown`) — Phase 7's MCP server subject module decodes
+ * them through its own schema. The scanner only emits one occurrence per
+ * server name.
+ */
+const McpConfigShapeSchema = Schema.Record(Schema.String, Schema.Unknown);
+const decodeMcpConfigShape = Schema.decodeUnknownEffect(McpConfigShapeSchema);
+// MCP configs can contain arbitrary, user-authored server names. Only names that
+// are valid AXM extension names can be managed; skip the rest instead of letting
+// a non-conforming name (e.g. uppercase or underscore) crash the whole scan.
+const decodeExtensionNameOption = Schema.decodeUnknownOption(ExtensionNameSchema);
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const extractServers = (decoded, serversKey) => !isRecord(decoded[serversKey])
+    ? []
+    : Object.entries(decoded[serversKey]).flatMap(([name, config]) => {
+        if (!isRecord(config))
+            return [];
+        const decodedName = decodeExtensionNameOption(name);
+        return Option.isNone(decodedName) ? [] : [{ name: decodedName.value, config }];
+    });
+const readMcpConfig = (fs, diagnostics, filePath) => Effect.gen(function* () {
+    const exists = yield* Effect.result(fs.exists(filePath));
+    if (exists._tag === "Failure") {
+        yield* diagnostics.append({
+            source: "scanner",
+            message: `${SCANNER_NAME}: cannot stat ${filePath}`,
+            path: filePath,
+            code: "scanner-io",
+        });
+        return Option.none();
+    }
+    if (!exists.success)
+        return Option.none();
+    const read = yield* Effect.result(fs.readFileString(filePath));
+    if (read._tag === "Failure") {
+        yield* diagnostics.append({
+            source: "scanner",
+            message: `${SCANNER_NAME}: cannot read ${filePath}`,
+            path: filePath,
+            code: "scanner-io",
+        });
+        return Option.none();
+    }
+    const parsed = yield* Effect.result(Effect.try({
+        try: () => {
+            const errors = [];
+            const value = parse(read.success, errors, { allowTrailingComma: true });
+            if (errors.length > 0)
+                throw errors;
+            return value;
+        },
+        catch: (cause) => ({ cause }),
+    }));
+    if (parsed._tag === "Failure") {
+        yield* diagnostics.append({
+            source: "scanner",
+            message: `${SCANNER_NAME}: cannot parse JSON at ${filePath}`,
+            path: filePath,
+            code: "scanner-parse",
+        });
+        return Option.none();
+    }
+    const decoded = yield* Effect.result(decodeMcpConfigShape(parsed.success));
+    if (decoded._tag === "Failure") {
+        yield* diagnostics.append({
+            source: "scanner",
+            message: `${SCANNER_NAME}: invalid MCP config shape at ${filePath}: ${decoded.failure.message}`,
+            path: filePath,
+            code: "scanner-parse",
+        });
+        return Option.none();
+    }
+    return Option.some(decoded.success);
+});
+const readMcpConfigCached = (cache, fs, diagnostics, filePath) => {
+    const existing = cache.get(filePath);
+    if (existing !== undefined)
+        return Effect.succeed(existing);
+    return readMcpConfig(fs, diagnostics, filePath).pipe(Effect.tap((decoded) => Effect.sync(() => {
+        cache.set(filePath, decoded);
+    })));
+};
+const hasMcpConfig = (capability) => capability.axm.writer !== null;
+const isCapabilityAgentId = (id) => id in CONFIGURABLE_AGENTS_BY_ID;
+const capabilityFor = (descriptor) => {
+    if (!isCapabilityAgentId(descriptor.id))
+        return undefined;
+    const agent = CONFIGURABLE_AGENTS_BY_ID[descriptor.id];
+    const capability = agent.capabilities["mcp-server"];
+    return hasMcpConfig(capability) ? capability : undefined;
+};
+const surfacePlanKey = (plan) => plan.surface._tag === "shared"
+    ? `shared:${plan.target.scope}:${plan.target.path}`
+    : `agent:${plan.surface.agentId}:${plan.target.scope}:${plan.target.path}`;
+const planMcpSurfaces = (scope, registry) => {
+    const plans = new Map();
+    for (const descriptor of Object.values(registry)) {
+        const capability = capabilityFor(descriptor);
+        if (capability === undefined)
+            continue;
+        for (const target of capability.axm.writer.config.targets) {
+            if (target.scope !== scope)
+                continue;
+            const surface = target.attribution === "shared"
+                ? { _tag: "shared" }
+                : { _tag: "agent", agentId: descriptor.id };
+            const plan = {
+                surface,
+                target,
+                serversKey: capability.axm.writer.config.serversKey,
+            };
+            const key = surfacePlanKey(plan);
+            if (!plans.has(key))
+                plans.set(key, plan);
+        }
+    }
+    return [...plans.values()];
+};
+const resolveMcpConfigTargetPath = (deps, target) => Effect.gen(function* () {
+    const { path, workspaceRoot, diagnostics } = deps;
+    const home = yield* getHome;
+    const configPath = target.scope === "user"
+        ? target.path.startsWith("~/")
+            ? path.join(home, target.path.slice(2))
+            : path.resolve(home, target.path)
+        : path.resolve(workspaceRoot, target.path);
+    if (target.scope === "project" && !isPathSafe(path, workspaceRoot, configPath)) {
+        yield* diagnostics.append({
+            source: "scanner",
+            message: `${SCANNER_NAME}: MCP config target escapes workspace root: ${target.path}`,
+            path: configPath,
+            code: "scanner-config",
+        });
+        return Option.none();
+    }
+    return Option.some(configPath);
+});
+const scanMcpSurface = (deps, plan, cache) => Effect.gen(function* () {
+    const { fs, path, scope, diagnostics } = deps;
+    const filePathOpt = yield* resolveMcpConfigTargetPath(deps, plan.target);
+    if (Option.isNone(filePathOpt))
+        return [];
+    const decoded = yield* readMcpConfigCached(cache, fs, diagnostics, filePathOpt.value);
+    if (Option.isNone(decoded))
+        return [];
+    const servers = extractServers(decoded.value, plan.serversKey);
+    const contentLocation = makeAbsolutePath(path, filePathOpt.value);
+    return servers.map((server) => ({
+        _tag: "mcp-config",
+        scope,
+        surface: plan.surface,
+        name: server.name,
+        contentLocation,
+        config: server.config,
+    }));
+});
+// ---------------------------------------------------------------------------
+// Scanner body
+// ---------------------------------------------------------------------------
+const scanMcpConfig = Effect.fn("workspace.read-model.scanner.mcp-config")(function* (deps) {
+    const registry = deps.agentRegistry ?? AGENTS;
+    const cache = new Map();
+    const plans = planMcpSurfaces(deps.scope, registry);
+    const occurrences = yield* Effect.forEach(plans, (plan) => scanMcpSurface(deps, plan, cache), {
+        concurrency: 1,
+    });
+    return occurrences.flat();
+});
+//# sourceMappingURL=mcp-config.js.map

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

@@ -0,0 +1,170 @@
+/**
+ * Shared scanner types: occurrence shape, common per-occurrence fields, and
+ * scanner-tier origin discriminators.
+ *
+ * Per Decision 5 of the workspace read-model design, scanner output is
+ * occurrence-shaped (`ReadonlyArray<Occurrence>`) — one entry per observable
+ * physical materialization. There is no central `DetectionOrigin` union; each
+ * scanner exports the discriminator it observes, and per-subject modules in
+ * Phase 7 map these scanner-tier discriminators into subject-specific origin
+ * unions.
+ *
+ * Identity of an actual entry is `(scope, type | agentId, origin, contentLocation)`.
+ * Two scanner paths observing the same physical occurrence collapse to one
+ * entry; two distinct physical paths under the same name produce two entries
+ * with different identities.
+ */
+import * as Option from "effect/Option";
+import type { ExtensionName, ExtensionType } from "@agentxm/extension-model/unstable/extensions/common";
+import type { Handle } from "@agentxm/extension-model/unstable/extensions/handle";
+import type { AgentId } from "@agentxm/extension-model/unstable/agents/types";
+import type { AbsolutePath } from "@agentxm/extension-model/unstable/path-types";
+import type { Scope } from "../types.js";
+/**
+ * Origin tag for an occurrence emitted by the canonical-extensions scanner.
+ * `canonical-axm` covers authored or owner-qualified packages;
+ * `external-axm` covers user-scope external-layout packages.
+ */
+export type CanonicalExtensionOriginKind = "canonical-axm" | "external-axm";
+/**
+ * One canonical package materialization observed in an authored root,
+ * `agent_extensions/`, or the user-scope `agent_extensions/` root.
+ *
+ * Fields:
+ *
+ * - `scope` — the scoping tier this occurrence belongs to (project | user).
+ * - `type` — the subject extension type.
+ * - `origin` — scanner-tier origin (canonical-axm | external-axm).
+ * - `name` — the subject's directory name (last segment under owner/type).
+ * - `owner` — the registry-owner prefix for canonical AXM, `null` for external.
+ * - `contentLocation` — absolute path on the synthesized FS to the subject's
+ *   content root (the directory itself, not a file inside it).
+ * - `pathSegments` — `contentLocation` split via the `Path` service. Subject
+ *   modules reach for this when they need to derive parent paths
+ *   (`packageRoot`, etc.) without re-parsing the string. Cross-platform safe.
+ * - `subjectFile` — `Some(path)` when the subject type has a canonical
+ *   primary content file (e.g., `<dir>/SKILL.md` for skills). `None` for
+ *   subject types that do not use a fixed primary file (mcp-server, file,
+ *   rule, pack).
+ * - `subjectFileExists` — `true` if the scanner probed `subjectFile` and found
+ *   it present. Always `false` when `subjectFile` is `None`. Subject modules
+ *   consume this rather than hardcoding presence.
+ */
+export interface CanonicalExtensionOccurrence {
+    readonly _tag: "canonical-extension";
+    readonly scope: Scope;
+    readonly type: ExtensionType;
+    readonly origin: CanonicalExtensionOriginKind;
+    readonly name: ExtensionName;
+    readonly owner: Handle | null;
+    readonly contentLocation: AbsolutePath;
+    readonly pathSegments: ReadonlyArray<string>;
+    readonly subjectFile: Option.Option<AbsolutePath>;
+    readonly subjectFileExists: boolean;
+}
+/**
+ * Subject types renderable into per-agent directories. Only the subjects
+ * actually observed by the v1 scanner are listed; rules render through
+ * subject-specific dirs that the agent registry does not currently encode and
+ * are therefore out of scope for the agent-dir scanner.
+ */
+export type AgentDirSubjectType = "skill" | "subagent";
+/**
+ * One materialization observed under a per-agent rendered directory
+ * (`.claude/skills/`, `.codex/agents/`, `.roomodes`,
+ * etc.). The origin discriminator carries the agent id so per-subject modules
+ * can map cleanly into agent-specific origins.
+ *
+ * Structural fields mirror `CanonicalExtensionOccurrence`:
+ *
+ * - `pathSegments` — `contentLocation` split via the `Path` service.
+ * - `subjectFile` — `Some(path)` when the subject type has a canonical
+ *   primary file (skill → `<dir>/SKILL.md`, command → `<dir>/${name}.md`,
+ *   subagent dir → `<dir>/${name}.md`). For single-file subagent surfaces
+ *   (e.g., `.roomodes`) the `subjectFile` is the `contentLocation` itself.
+ * - `subjectFileExists` — `true` if the scanner probed `subjectFile` and
+ *   found it present. Always `false` when `subjectFile` is `None`. For
+ *   single-file subagents this is always `true` because presence of the file
+ *   is what produced the occurrence.
+ */
+export interface AgentDirOccurrence {
+    readonly _tag: "agent-dir";
+    readonly scope: Scope;
+    readonly type: AgentDirSubjectType;
+    readonly agentId: AgentId;
+    /** Primary write path or the catalog status of an additional read-only path. */
+    readonly readPathStatus?: "primary" | "canonical" | "compat" | "deprecated";
+    readonly name: string;
+    readonly contentLocation: AbsolutePath;
+    readonly pathSegments: ReadonlyArray<string>;
+    readonly subjectFile: Option.Option<AbsolutePath>;
+    readonly subjectFileExists: boolean;
+}
+/** Physical MCP configuration surface that supplied an observation. */
+export type McpConfigSurface = {
+    readonly _tag: "shared";
+} | {
+    readonly _tag: "agent";
+    readonly agentId: AgentId;
+};
+/** One MCP server entry observed on one physical configuration surface. */
+export interface McpConfigOccurrence {
+    readonly _tag: "mcp-config";
+    readonly scope: Scope;
+    readonly surface: McpConfigSurface;
+    readonly name: ExtensionName;
+    readonly contentLocation: AbsolutePath;
+    readonly config: Readonly<Record<string, unknown>>;
+}
+/**
+ * One agent-native settings file observed on disk (e.g.,
+ * `.claude/settings.json`).
+ *
+ * `contentLocation` is the absolute path to the settings file. There is no
+ * "name" in the subject sense — the file itself is the materialization, keyed
+ * by `agentId`.
+ */
+export interface AgentSettingsOccurrence {
+    readonly _tag: "agent-settings";
+    readonly scope: Scope;
+    readonly agentId: AgentId;
+    readonly contentLocation: AbsolutePath;
+}
+/**
+ * Stable occurrence identity tuple. The four-part shape mirrors the spec's
+ * "Actual entries carry stable occurrence identity" requirement:
+ * `(scope, type | agentId, origin, contentLocation)`. `subjectKey` is the
+ * subject discriminator — extension type for extension occurrences, agent id
+ * for agent occurrences.
+ */
+export interface OccurrenceIdentity {
+    readonly scope: Scope;
+    readonly subjectKey: string;
+    readonly origin: string;
+    readonly contentLocation: string;
+}
+/**
+ * All occurrence shapes scanners emit. The discriminator on `_tag` lets
+ * downstream subject modules narrow without a centralized origin union.
+ */
+export type ScannerOccurrence = CanonicalExtensionOccurrence | AgentDirOccurrence | McpConfigOccurrence | AgentSettingsOccurrence;
+/**
+ * Compute the identity tuple for one occurrence. Two scanner paths observing
+ * the same physical occurrence produce equal identities; distinct physical
+ * paths under the same name produce different identities.
+ */
+export declare const occurrenceIdentity: (occurrence: ScannerOccurrence) => OccurrenceIdentity;
+/**
+ * Serialize an `OccurrenceIdentity` to a stable string key. Two occurrences
+ * with identical identity tuples produce equal strings; differences in any
+ * tuple field produce different strings. The encoding uses a delimiter that
+ * cannot appear in a relative path or origin tag.
+ */
+export declare const occurrenceIdentityKey: (id: OccurrenceIdentity) => string;
+/**
+ * Convenience: collapse an occurrence array to one entry per identity. The
+ * first occurrence with a given identity wins; subsequent observations are
+ * dropped. Stable ordering: input order is preserved for first-seen entries.
+ */
+export declare const dedupeByIdentity: <T extends ScannerOccurrence>(occurrences: ReadonlyArray<T>) => ReadonlyArray<T>;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/workspace/read-model/scanners/types.js

@@ -0,0 +1,86 @@
+/**
+ * Shared scanner types: occurrence shape, common per-occurrence fields, and
+ * scanner-tier origin discriminators.
+ *
+ * Per Decision 5 of the workspace read-model design, scanner output is
+ * occurrence-shaped (`ReadonlyArray<Occurrence>`) — one entry per observable
+ * physical materialization. There is no central `DetectionOrigin` union; each
+ * scanner exports the discriminator it observes, and per-subject modules in
+ * Phase 7 map these scanner-tier discriminators into subject-specific origin
+ * unions.
+ *
+ * Identity of an actual entry is `(scope, type | agentId, origin, contentLocation)`.
+ * Two scanner paths observing the same physical occurrence collapse to one
+ * entry; two distinct physical paths under the same name produce two entries
+ * with different identities.
+ */
+import * as Option from "effect/Option";
+/**
+ * Compute the identity tuple for one occurrence. Two scanner paths observing
+ * the same physical occurrence produce equal identities; distinct physical
+ * paths under the same name produce different identities.
+ */
+export const occurrenceIdentity = (occurrence) => {
+    switch (occurrence._tag) {
+        case "canonical-extension":
+            return {
+                scope: occurrence.scope,
+                subjectKey: occurrence.type,
+                origin: occurrence.origin,
+                contentLocation: occurrence.contentLocation,
+            };
+        case "agent-dir":
+            return {
+                scope: occurrence.scope,
+                subjectKey: `${occurrence.type}:${occurrence.agentId}`,
+                origin: `agent-dir:${occurrence.agentId}`,
+                contentLocation: occurrence.contentLocation,
+            };
+        case "mcp-config":
+            return occurrence.surface._tag === "shared"
+                ? {
+                    scope: occurrence.scope,
+                    subjectKey: "mcp-server",
+                    origin: "shared-mcp-config",
+                    contentLocation: `${occurrence.contentLocation}#${occurrence.name}`,
+                }
+                : {
+                    scope: occurrence.scope,
+                    subjectKey: `mcp-server:${occurrence.surface.agentId}`,
+                    origin: `agent-mcp-config:${occurrence.surface.agentId}`,
+                    contentLocation: `${occurrence.contentLocation}#${occurrence.name}`,
+                };
+        case "agent-settings":
+            return {
+                scope: occurrence.scope,
+                subjectKey: `agent-settings:${occurrence.agentId}`,
+                origin: `agent-settings:${occurrence.agentId}`,
+                contentLocation: occurrence.contentLocation,
+            };
+    }
+};
+/**
+ * Serialize an `OccurrenceIdentity` to a stable string key. Two occurrences
+ * with identical identity tuples produce equal strings; differences in any
+ * tuple field produce different strings. The encoding uses a delimiter that
+ * cannot appear in a relative path or origin tag.
+ */
+export const occurrenceIdentityKey = (id) => `${id.scope}\u0000${id.subjectKey}\u0000${id.origin}\u0000${id.contentLocation}`;
+/**
+ * Convenience: collapse an occurrence array to one entry per identity. The
+ * first occurrence with a given identity wins; subsequent observations are
+ * dropped. Stable ordering: input order is preserved for first-seen entries.
+ */
+export const dedupeByIdentity = (occurrences) => {
+    const seen = new Set();
+    const out = [];
+    for (const occ of occurrences) {
+        const key = occurrenceIdentityKey(occurrenceIdentity(occ));
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(occ);
+    }
+    return out;
+};
+//# sourceMappingURL=types.js.map

package/dist/src/workspace/read-model/service.d.ts

@@ -0,0 +1,103 @@
+/** Per-scope read-only workspace model factory and configuration. */
+import * as Brand from "effect/Brand";
+import * as ServiceMap from "effect/Context";
+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 Handle } from "@agentxm/extension-model/unstable/extensions/handle";
+import type { SourceHostConfig } from "../../settings/schema.js";
+import { type AbsolutePath } from "@agentxm/extension-model/unstable/path-types";
+import { AgentRootResolver } from "./agent-root-resolver.js";
+import { type ScopedAgentsApi } from "./agents/index.js";
+import { type Warning } from "./diagnostics.js";
+import { WorkspaceRootEscape, type LockfileIoError, type SettingsIoError, type SettingsReadError } from "./errors.js";
+import { type HookExtensionsApi, type KnowledgeExtensionsApi, type McpServerExtensionsApi, type PackExtensionsApi, type RuleExtensionsApi, type SkillExtensionsApi, type SubagentExtensionsApi } from "./extensions/index.js";
+import { type CanonicalExtensionOccurrence } from "./scanners/index.js";
+import { type RawSourceBytes, type ScopedStateLoaders } from "./state.js";
+import type { Scope } from "./types.js";
+export type { RawSourceBytes } from "./state.js";
+/** Scoped state cells; `raw(source)` reads cached bytes (absent → `Option.none`). */
+export interface ScopedStateApi {
+    readonly settings: ScopedStateLoaders["settings"];
+    readonly lockfile: ScopedStateLoaders["lockfile"];
+    readonly raw: (source: "settings" | "lockfile") => Effect.Effect<Option.Option<RawSourceBytes>, SettingsIoError | LockfileIoError>;
+}
+/** Scoped source-host views over the cached settings loader. */
+export interface ScopedSourceHostsApi {
+    readonly declared: Effect.Effect<ReadonlyArray<SourceHostConfig>, SettingsReadError>;
+    readonly effective: Effect.Effect<ReadonlyArray<SourceHostConfig>, SettingsReadError>;
+    readonly registryHosts: Effect.Effect<ReadonlyArray<Extract<SourceHostConfig, {
+        type: "registry";
+    }>>, SettingsReadError>;
+    readonly byName: (name: string) => Effect.Effect<Option.Option<SourceHostConfig>, SettingsReadError>;
+}
+/** Scoped owner view over the cached settings loader (declared owner; no fallback). */
+export type ScopedOwnerApi = Effect.Effect<Option.Option<Handle>, SettingsReadError>;
+/**
+ * Workspace read model for a single scope (project or user).
+ *
+ * Returned by {@link makeWorkspaceReadModel}. Each invocation builds its own
+ * scoped cells; cells cache for the lifetime of the returned value.
+ */
+export interface WorkspaceReadModel {
+    readonly scope: Scope;
+    readonly skills: SkillExtensionsApi;
+    readonly mcpServers: McpServerExtensionsApi;
+    readonly subagents: SubagentExtensionsApi;
+    readonly rules: RuleExtensionsApi;
+    readonly hooks: HookExtensionsApi;
+    readonly knowledge: KnowledgeExtensionsApi;
+    readonly packs: PackExtensionsApi;
+    readonly agents: ScopedAgentsApi;
+    readonly state: ScopedStateApi;
+    readonly sourceHosts: ScopedSourceHostsApi;
+    readonly owner: ScopedOwnerApi;
+    readonly diagnostics: Effect.Effect<ReadonlyArray<Warning>>;
+    readonly canonicalExtensions: Effect.Effect<ReadonlyArray<CanonicalExtensionOccurrence>>;
+}
+/**
+ * The read-model family that carries each catalog extension type, or `null`
+ * where no family exists yet.
+ *
+ * Total by construction: a new extension type fails compile here until its
+ * read-model coverage is decided. The parity conformance suite reads this map
+ * to check the read-model obligation, and every `null` must be matched by a
+ * ledger row.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const READ_MODEL_EXTENSION_FAMILY_BY_TYPE: {
+    readonly skill: "skills";
+    readonly "mcp-server": "mcpServers";
+    readonly subagent: "subagents";
+    readonly rule: "rules";
+    readonly hook: "hooks";
+    readonly knowledge: "knowledge";
+};
+/** Configuration the factory requires beyond `FileSystem` and `Path`. */
+export interface WorkspaceReadModelConfigService {
+    readonly projectRoot: AbsolutePath;
+    readonly userHome: AbsolutePath;
+    readonly allowedRoot: AbsolutePath;
+}
+declare const WorkspaceReadModelConfig_base: ServiceMap.ServiceClass<WorkspaceReadModelConfig, "@agentxm/workspace-state/workspace/read-model/service/WorkspaceReadModelConfig", WorkspaceReadModelConfigService>;
+/** Service tag for the {@link WorkspaceReadModelConfigService} the factory requires. */
+export declare class WorkspaceReadModelConfig extends WorkspaceReadModelConfig_base {
+}
+/** Workspace root that has been validated against `allowedRoot`. */
+export type ResolvedWorkspaceRoot = string & Brand.Brand<"ResolvedWorkspaceRoot">;
+/**
+ * Build a {@link WorkspaceReadModel} for the requested scope.
+ *
+ * Each invocation produces a fresh instance with its own cached cells; call
+ * once at the command boundary and pass the value inward. Callers that need
+ * both scopes invoke the factory twice.
+ *
+ * Cross-scope state (the agent-root resolver and its collision warnings) is
+ * supplied by {@link AgentRootResolver}, which must be provided in the
+ * environment so the same warnings flow into every scope built against the
+ * same layer.
+ */
+export declare const makeWorkspaceReadModel: (scope: Scope) => Effect.Effect<WorkspaceReadModel, WorkspaceRootEscape, FileSystem.FileSystem | Path.Path | WorkspaceReadModelConfig | AgentRootResolver>;
+//# sourceMappingURL=service.d.ts.map