@agentxm/workspace-state 0.28.4-bootstrap.0

package/dist/src/workspace/setup-scope-support.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Effective setup scope support derived from the extension-type and coding-agent catalogs.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { type ExtensionType, type ExtensionPlacement } from "@agentxm/extension-model/unstable/extensions/common";
+import type { WorkspaceScope } from "@agentxm/extension-model/unstable/workspace-scope";
+export type SetupScopeSupportStatus = "supported" | "project-only" | "unsupported" | "refused";
+export type SetupScopeSupportReasonCode = "supported" | "no-configured-agents" | "unknown-agent" | "native-capability-unavailable" | "axm-capability-unavailable" | "project-only" | "scope-not-modeled";
+export interface SetupScopeSupportOutcome {
+    readonly target: "workspace" | "container" | "agent" | "agent-set";
+    readonly agentId?: string;
+    readonly agentName?: string;
+    readonly status: SetupScopeSupportStatus;
+    readonly reasonCode: SetupScopeSupportReasonCode;
+    readonly reason: string;
+}
+export interface SetupScopeSupportCategory {
+    readonly type: ExtensionType;
+    readonly label: string;
+    readonly placement: ExtensionPlacement;
+    readonly outcomes: ReadonlyArray<SetupScopeSupportOutcome>;
+}
+export declare const setupScopeSupportOutcomes: (type: ExtensionType, agentIds: ReadonlyArray<string>, scope: WorkspaceScope) => ReadonlyArray<SetupScopeSupportOutcome>;
+/** Derive setup's category and per-agent scope contract from canonical catalogs. */
+export declare const setupScopeSupport: (agentIds: ReadonlyArray<string>, scope: WorkspaceScope) => ReadonlyArray<SetupScopeSupportCategory>;
+//# sourceMappingURL=setup-scope-support.d.ts.map

package/dist/src/workspace/setup-scope-support.js

@@ -0,0 +1,299 @@
+/**
+ * Effective setup scope support derived from the extension-type and coding-agent catalogs.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { CONFIGURABLE_AGENTS_BY_ID, } from "@agentxm/extension-model/unstable/agent-capabilities";
+import { userScopeRefusal } from "./scope-refusal.js";
+import { EXTENSION_TYPE_TABLE, extensionTypeLabels, extensionTypes, } from "@agentxm/extension-model/unstable/extensions/common";
+const isConfigurableAgentId = (id) => Object.hasOwn(CONFIGURABLE_AGENTS_BY_ID, id);
+const nativeSupportsScope = (native, scope) => native.availability.via !== "none" && "scopes" in native && native.scopes.includes(scope);
+const capabilityReason = (axm, fallback) => typeof axm === "object" && axm !== null && "reason" in axm && typeof axm.reason === "string"
+    ? axm.reason
+    : fallback;
+const supportedOutcome = (args) => ({
+    ...args,
+    status: "supported",
+    reasonCode: "supported",
+});
+const agentOutcome = (args) => ({ target: "agent", ...args });
+const noConfiguredAgentsOutcome = () => ({
+    target: "agent-set",
+    status: "unsupported",
+    reasonCode: "no-configured-agents",
+    reason: "No coding agents are configured for this scope.",
+});
+const unknownAgentOutcome = (agentId) => agentOutcome({
+    agentId,
+    agentName: agentId,
+    status: "unsupported",
+    reasonCode: "unknown-agent",
+    reason: `${agentId} is not present in the coding-agent capability catalog.`,
+});
+const capabilityUnavailableOutcome = (args) => agentOutcome({
+    agentId: args.agentId,
+    agentName: args.agentName,
+    status: "unsupported",
+    reasonCode: args.axmReason === undefined ? "native-capability-unavailable" : "axm-capability-unavailable",
+    reason: args.axmReason ??
+        `${args.agentName} has no supported ${args.typeLabel.toLowerCase()} surface.`,
+});
+const projectOnlyOutcome = (args) => agentOutcome({
+    agentId: args.agentId,
+    agentName: args.agentName,
+    status: "project-only",
+    reasonCode: "project-only",
+    reason: args.reason ??
+        `${args.agentName} supports ${args.typeLabel.toLowerCase()} only in project scope.`,
+});
+const scopeNotModeledOutcome = (args) => agentOutcome({
+    agentId: args.agentId,
+    agentName: args.agentName,
+    status: "refused",
+    reasonCode: "scope-not-modeled",
+    reason: args.reason ??
+        `AXM has not modeled ${args.typeLabel.toLowerCase()} for ${args.agentName} in user scope.`,
+});
+const perAgentOutcomes = (agentIds, resolve) => {
+    if (agentIds.length === 0)
+        return [noConfiguredAgentsOutcome()];
+    return agentIds.map((agentId) => isConfigurableAgentId(agentId) ? resolve(agentId) : unknownAgentOutcome(agentId));
+};
+const skillOutcome = (agentId, scope) => {
+    const agent = CONFIGURABLE_AGENTS_BY_ID[agentId];
+    const capability = agent.capabilities.skill;
+    const projectSupported = capability.axm.status === "supported" && nativeSupportsScope(capability.native, "project");
+    if (capability.native.availability.via === "none") {
+        return capabilityUnavailableOutcome({
+            agentId,
+            agentName: agent.name,
+            typeLabel: "Skills",
+        });
+    }
+    if (capability.axm.status !== "supported") {
+        return capabilityUnavailableOutcome({
+            agentId,
+            agentName: agent.name,
+            typeLabel: "Skills",
+            axmReason: capabilityReason(capability.axm, `AXM does not support skills for ${agent.name}.`),
+        });
+    }
+    if (nativeSupportsScope(capability.native, scope)) {
+        return supportedOutcome({
+            target: "agent",
+            agentId,
+            agentName: agent.name,
+            reason: `${agent.name} supports skills in ${scope} scope.`,
+        });
+    }
+    return projectSupported
+        ? projectOnlyOutcome({ agentId, agentName: agent.name, typeLabel: "Skills" })
+        : capabilityUnavailableOutcome({ agentId, agentName: agent.name, typeLabel: "Skills" });
+};
+const mcpOutcome = (agentId, scope) => {
+    const agent = CONFIGURABLE_AGENTS_BY_ID[agentId];
+    const capability = agent.capabilities["mcp-server"];
+    if (capability.native.availability.via === "none") {
+        return capabilityUnavailableOutcome({
+            agentId,
+            agentName: agent.name,
+            typeLabel: "MCP servers",
+        });
+    }
+    if (capability.axm.status !== "supported" || capability.axm.writer === null) {
+        return capabilityUnavailableOutcome({
+            agentId,
+            agentName: agent.name,
+            typeLabel: "MCP servers",
+            axmReason: capabilityReason(capability.axm, `AXM has no supported MCP writer for ${agent.name}.`),
+        });
+    }
+    const targets = capability.axm.writer.config.targets;
+    const hasTarget = targets.some((target) => target.scope === scope);
+    if (nativeSupportsScope(capability.native, scope) && hasTarget) {
+        return supportedOutcome({
+            target: "agent",
+            agentId,
+            agentName: agent.name,
+            reason: `${agent.name} has an AXM-managed ${scope}-scope MCP target.`,
+        });
+    }
+    const hasProjectTarget = targets.some((target) => target.scope === "project");
+    if (scope === "user" && nativeSupportsScope(capability.native, "user") && hasProjectTarget) {
+        return scopeNotModeledOutcome({
+            agentId,
+            agentName: agent.name,
+            typeLabel: "MCP servers",
+            reason: `AXM manages only project-scope MCP configuration for ${agent.name}; the native user-scope surface is not modeled.`,
+        });
+    }
+    return scope === "user" && hasProjectTarget
+        ? projectOnlyOutcome({ agentId, agentName: agent.name, typeLabel: "MCP servers" })
+        : capabilityUnavailableOutcome({
+            agentId,
+            agentName: agent.name,
+            typeLabel: "MCP servers",
+        });
+};
+const subagentOutcome = (agentId, scope) => {
+    const agent = CONFIGURABLE_AGENTS_BY_ID[agentId];
+    const capability = agent.capabilities.subagent;
+    const projectSupported = capability.native.availability.via !== "none" &&
+        capability.axm.status === "supported" &&
+        nativeSupportsScope(capability.native, "project");
+    if (!projectSupported) {
+        return capabilityUnavailableOutcome({
+            agentId,
+            agentName: agent.name,
+            typeLabel: "Subagents",
+            ...(capability.axm.status === "supported"
+                ? {}
+                : {
+                    axmReason: capabilityReason(capability.axm, `AXM does not support subagents for ${agent.name}.`),
+                }),
+        });
+    }
+    if (scope === "project") {
+        return supportedOutcome({
+            target: "agent",
+            agentId,
+            agentName: agent.name,
+            reason: `${agent.name} has an AXM-managed project-scope subagent target.`,
+        });
+    }
+    const reason = userScopeRefusal({ agentId, agentName: agent.name, type: "subagents" });
+    return nativeSupportsScope(capability.native, "user")
+        ? scopeNotModeledOutcome({
+            agentId,
+            agentName: agent.name,
+            typeLabel: "Subagents",
+            reason,
+        })
+        : projectOnlyOutcome({
+            agentId,
+            agentName: agent.name,
+            typeLabel: "Subagents",
+            reason,
+        });
+};
+const hookOutcome = (agentId, scope) => {
+    const agent = CONFIGURABLE_AGENTS_BY_ID[agentId];
+    const capability = agent.capabilities.hook;
+    if (capability.native.availability.via === "none" ||
+        capability.axm.status !== "supported" ||
+        capability.axm.writer === null) {
+        return capabilityUnavailableOutcome({
+            agentId,
+            agentName: agent.name,
+            typeLabel: "Hooks",
+            ...(capability.axm.status === "supported"
+                ? {}
+                : {
+                    axmReason: capabilityReason(capability.axm, `AXM does not support hooks for ${agent.name}.`),
+                }),
+        });
+    }
+    const hasProjectTarget = capability.axm.writer.configFiles.some((target) => target.scope === "project");
+    if (!hasProjectTarget) {
+        return capabilityUnavailableOutcome({
+            agentId,
+            agentName: agent.name,
+            typeLabel: "Hooks",
+            axmReason: `AXM has no project-scope hook writer target for ${agent.name}.`,
+        });
+    }
+    if (scope === "user") {
+        return projectOnlyOutcome({
+            agentId,
+            agentName: agent.name,
+            typeLabel: "Hooks",
+            reason: `AXM hook materialization for ${agent.name} is intentionally project-only.`,
+        });
+    }
+    return supportedOutcome({
+        target: "agent",
+        agentId,
+        agentName: agent.name,
+        reason: `${agent.name} has an AXM-managed project-scope hook target.`,
+    });
+};
+const instructionOutcome = (agentId, scope) => {
+    const agent = CONFIGURABLE_AGENTS_BY_ID[agentId];
+    const capability = agent.instructions;
+    if (capability.native.availability.via === "none") {
+        return capabilityUnavailableOutcome({
+            agentId,
+            agentName: agent.name,
+            typeLabel: "instruction files",
+        });
+    }
+    if (capability.axm.status !== "supported") {
+        return capabilityUnavailableOutcome({
+            agentId,
+            agentName: agent.name,
+            typeLabel: "instruction files",
+            axmReason: capabilityReason(capability.axm, `AXM does not support instruction projection for ${agent.name}.`),
+        });
+    }
+    if (nativeSupportsScope(capability.native, scope)) {
+        return supportedOutcome({
+            target: "agent",
+            agentId,
+            agentName: agent.name,
+            reason: `${agent.name} supports instruction files in ${scope} scope.`,
+        });
+    }
+    return scope === "user" && nativeSupportsScope(capability.native, "project")
+        ? projectOnlyOutcome({
+            agentId,
+            agentName: agent.name,
+            typeLabel: "instruction files",
+        })
+        : capabilityUnavailableOutcome({
+            agentId,
+            agentName: agent.name,
+            typeLabel: "instruction files",
+        });
+};
+export const setupScopeSupportOutcomes = (type, agentIds, scope) => {
+    switch (type) {
+        case "skill":
+            return perAgentOutcomes(agentIds, (agentId) => skillOutcome(agentId, scope));
+        case "mcp-server":
+            return perAgentOutcomes(agentIds, (agentId) => mcpOutcome(agentId, scope));
+        case "subagent":
+            return perAgentOutcomes(agentIds, (agentId) => subagentOutcome(agentId, scope));
+        case "hook":
+            return perAgentOutcomes(agentIds, (agentId) => hookOutcome(agentId, scope));
+        case "rule":
+            return [
+                supportedOutcome({
+                    target: "workspace",
+                    reason: `Rule packages and the canonical instruction source are supported in ${scope} scope.`,
+                }),
+                ...perAgentOutcomes(agentIds, (agentId) => instructionOutcome(agentId, scope)),
+            ];
+        case "knowledge":
+            return [
+                supportedOutcome({
+                    target: "workspace",
+                    reason: `Knowledge bundles are supported in ${scope} scope.`,
+                }),
+            ];
+        case "pack":
+            return [
+                supportedOutcome({
+                    target: "container",
+                    reason: `Pack intent is supported in ${scope} scope; member outcomes follow their categories.`,
+                }),
+            ];
+    }
+};
+/** Derive setup's category and per-agent scope contract from canonical catalogs. */
+export const setupScopeSupport = (agentIds, scope) => extensionTypes.map((type) => ({
+    type,
+    label: extensionTypeLabels[type],
+    placement: EXTENSION_TYPE_TABLE[type].placement,
+    outcomes: setupScopeSupportOutcomes(type, agentIds, scope),
+}));
+//# sourceMappingURL=setup-scope-support.js.map

package/dist/src/workspace/skill-paths.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Centralized skill path computation.
+ *
+ * Provides types and a pure function for computing skill directory paths
+ * based on source type (registry vs non-registry).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { type ExtensionPathSource } from "./extension-paths.js";
+import type { AbsolutePath } from "@agentxm/extension-model/unstable/path-types";
+import type { WorkspaceLayout } from "./layout.js";
+/**
+ * Minimal structural discriminant for determining skill path layout.
+ *
+ * Every acquired ref carries enough source coordinates to derive its
+ * source-qualified canonical path.
+ */
+export type SkillPathSource = ExtensionPathSource;
+/**
+ * Computed paths for an installed skill directory.
+ *
+ * - `canonicalPath`: root of the installed skill
+ * - `skillSrcPath`: where actual skill source files live
+ *
+ * Native packages use `<canonicalPath>/src`; portable Agent Skills use the
+ * source-qualified package root directly.
+ */
+export interface SkillDirPaths {
+    readonly canonicalPath: AbsolutePath;
+    readonly skillSrcPath: AbsolutePath;
+}
+export declare const computeSkillPathsForLayout: (join: (...paths: string[]) => string, layout: WorkspaceLayout, source: SkillPathSource, sanitizedName: string) => SkillDirPaths;
+//# sourceMappingURL=skill-paths.d.ts.map

package/dist/src/workspace/skill-paths.js

@@ -0,0 +1,14 @@
+/**
+ * Centralized skill path computation.
+ *
+ * Provides types and a pure function for computing skill directory paths
+ * based on source type (registry vs non-registry).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { computeExtensionPathsForLayout } from "./extension-paths.js";
+export const computeSkillPathsForLayout = (join, layout, source, sanitizedName) => {
+    const paths = computeExtensionPathsForLayout(join, layout, source, "skills", sanitizedName);
+    return { canonicalPath: paths.canonicalPath, skillSrcPath: paths.extensionSrcPath };
+};
+//# sourceMappingURL=skill-paths.js.map

package/dist/src/workspace/source-metadata.d.ts

@@ -0,0 +1,7 @@
+/** Source metadata derivation helpers. */
+import type { PackagingKind } from "./read-model-record-types.js";
+export type SourceMeta = {
+    readonly packagingKind: PackagingKind;
+};
+export declare const deriveSourceMetaFromLockType: (lockType: string) => SourceMeta;
+//# sourceMappingURL=source-metadata.d.ts.map

package/dist/src/workspace/source-metadata.js

@@ -0,0 +1,10 @@
+/** Source metadata derivation helpers. */
+export const deriveSourceMetaFromLockType = (lockType) => {
+    switch (lockType) {
+        case "registry":
+            return { packagingKind: "native" };
+        default:
+            return { packagingKind: "non-native" };
+    }
+};
+//# sourceMappingURL=source-metadata.js.map

package/dist/src/workspace/source-to-lock-entry.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Maps a SkillExtensionRef to the corresponding SkillLockEntry.
+ *
+ * Pure function that converts from the runtime SkillExtensionRef types
+ * (which use Option<T>) to the lockfile schema types (which use T | undefined
+ * via Schema.optional).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Option from "effect/Option";
+import type { SkillLockEntry } from "../lockfile/schema.js";
+import type { SourceHash } from "@agentxm/extension-model/unstable/sources/source-hash";
+import type { TreeIntegrity } from "./materialized-tree.js";
+import type { SkillExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/skill";
+export interface SourceToLockEntryInput {
+    readonly ref: SkillExtensionRef;
+    /** Required for registry sources — which named registry config was used. */
+    readonly sourceName: Option.Option<string>;
+    /** Canonical package identity required by Git and local-path resolutions. */
+    readonly contentIdentity: SourceHash;
+    readonly treeIntegrity: TreeIntegrity;
+    /** Workspace-root-relative local source path for lockfile persistence. */
+    readonly workspaceRelativeLocalSourcePath?: Option.Option<string>;
+}
+/**
+ * Maps a SkillExtensionRef and operation metadata to a SkillLockEntry for lockfile persistence.
+ *
+ * Outer switch on `ref.refType` for ref-detail access; inner switch on `ref.source.type`
+ * within `git-hosted` for per-source lock entry granularity.
+ */
+export declare const sourceToLockEntry: (input: SourceToLockEntryInput) => SkillLockEntry | undefined;
+//# sourceMappingURL=source-to-lock-entry.d.ts.map

package/dist/src/workspace/source-to-lock-entry.js

@@ -0,0 +1,68 @@
+/**
+ * Maps a SkillExtensionRef to the corresponding SkillLockEntry.
+ *
+ * Pure function that converts from the runtime SkillExtensionRef types
+ * (which use Option<T>) to the lockfile schema types (which use T | undefined
+ * via Schema.optional).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Option from "effect/Option";
+import { gitSourceLockFields, portableGitSourceLockFields } from "../lockfile/entry-fields.js";
+// -----------------------------------------------------------------------------
+// Helpers
+// -----------------------------------------------------------------------------
+const localSourceLockPath = (input, sourcePath) => Option.getOrElse(input.workspaceRelativeLocalSourcePath ?? Option.none(), () => sourcePath);
+// -----------------------------------------------------------------------------
+// Implementation
+// -----------------------------------------------------------------------------
+/**
+ * Maps a SkillExtensionRef and operation metadata to a SkillLockEntry for lockfile persistence.
+ *
+ * Outer switch on `ref.refType` for ref-detail access; inner switch on `ref.source.type`
+ * within `git-hosted` for per-source lock entry granularity.
+ */
+export const sourceToLockEntry = (input) => {
+    const { ref } = input;
+    switch (ref.refType) {
+        case "git-hosted":
+            return {
+                ...(ref.owner === undefined
+                    ? portableGitSourceLockFields(ref.source, ref.skill.name, Option.fromUndefinedOr(ref.sourcePath), ref.gitCommitSha, ref.gitTreeSha, input.contentIdentity, ref.name, input.treeIntegrity)
+                    : gitSourceLockFields(ref.source, "skill", ref.skill.name, Option.fromUndefinedOr(ref.sourcePath), ref.gitCommitSha, ref.gitTreeSha, input.contentIdentity, ref.owner, ref.name, input.treeIntegrity)),
+            };
+        case "local":
+            return {
+                type: "local",
+                sourceType: "local",
+                sourceName: "local",
+                extensionType: "skill",
+                workspaceName: ref.skill.name,
+                packageFormat: ref.portable === true ? "agent-skill" : "agentxm",
+                ...(ref.owner === undefined ? {} : { packageOwner: ref.owner }),
+                packageName: ref.name,
+                path: localSourceLockPath(input, ref.source.path),
+                contentIdentity: input.contentIdentity,
+                treeIntegrity: input.treeIntegrity,
+            };
+        case "registry":
+            return {
+                type: "registry",
+                sourceType: "registry",
+                packageFormat: "agentxm",
+                endpoint: ref.source.location,
+                extensionType: "skill",
+                workspaceName: ref.skill.name,
+                owner: ref.owner,
+                name: ref.skill.name,
+                resolvedVersion: ref.version,
+                integrity: Option.getOrElse(ref.integrity, () => ""),
+                sourceName: ref.source.name,
+                publisherBindingId: ref.publisherBindingId,
+                treeIntegrity: input.treeIntegrity,
+            };
+        case "workspace":
+            return undefined;
+    }
+};
+//# sourceMappingURL=source-to-lock-entry.js.map

package/dist/src/workspace/test-stubs.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Default no-op stubs for workspace getter methods on WorkspaceMutationsService.
+ * Spread into test mocks to satisfy the interface without implementing every method.
+ *
+ * @internal Test-only. Not exported from the barrel.
+ */
+import * as Effect from "effect/Effect";
+import type { WorkspaceMutationsService } from "./service-interface.js";
+import type { ReadModelRecordRow, PackagingKind } from "./read-model-record-types.js";
+import type { WorkspaceStateReadFailure } from "./service-interface.js";
+import type { ExtensionInventory } from "./read-model/extensions/inventory.js";
+import { type McpServerLockEntry, type RegistryPackLockEntry, type SkillLockEntry } from "../lockfile/index.js";
+import { type InstallableExtensionType } from "@agentxm/extension-model/unstable/extensions/installable-types";
+import { type Handle } from "@agentxm/extension-model/unstable/extensions/handle";
+import { type Version } from "@agentxm/extension-model/unstable/version-constraints";
+type WorkspaceMockOverrides = Partial<WorkspaceMutationsService> & Partial<WorkspaceMutationsService["records"]>;
+/**
+ * Build a `configured` read-model row. Tests that previously stubbed
+ * `getConfiguredSkills` with a `{ name: { source, enabled } }` map supply the
+ * same facts here and feed the result to {@link rowsFor}.
+ */
+export declare const configuredRow: (args: {
+    readonly type: InstallableExtensionType;
+    readonly name: string;
+    readonly source: string;
+    readonly enabled?: boolean;
+    readonly packagingKind?: PackagingKind;
+}) => ReadModelRecordRow;
+/** Build an `implicit` read-model row (pack member or lockfile-only entry). */
+export declare const implicitRow: (args: {
+    readonly type: InstallableExtensionType;
+    readonly name: string;
+    readonly source?: string;
+    readonly packagingKind?: PackagingKind;
+}) => ReadModelRecordRow;
+/** Build an `unmanaged` read-model row (observed on disk, unclaimed). */
+export declare const unmanagedRow: (args: {
+    readonly type: InstallableExtensionType;
+    readonly name: string;
+    readonly locations?: ReadonlyArray<string>;
+    readonly packagingKind?: PackagingKind;
+}) => ReadModelRecordRow;
+/**
+ * Build a `records.rows` stub from per-type row lists. Types absent from the
+ * map yield an empty array, matching the real reader's totality.
+ */
+export declare const rowsFor: (byType: Partial<Record<InstallableExtensionType, ReadonlyArray<ReadModelRecordRow>>>) => (type: InstallableExtensionType) => Effect.Effect<ReadonlyArray<ReadModelRecordRow>, WorkspaceStateReadFailure>;
+/**
+ * No-op stubs for all read-model record getters. Spread into mock objects:
+ * ```ts
+ * const ws: WorkspaceMutationsService = {
+ *   records: readModelRecordStubs,
+ *   // your overrides
+ * };
+ * ```
+ */
+export declare const readModelRecordStubs: {
+    readonly getInventory: () => Effect.Effect<{
+        items: never[];
+        count: number;
+        configuredCount: number;
+        implicitCount: number;
+        installedCount: number;
+        unmanagedCount: number;
+    }, never, never>;
+    readonly getExtensionInventory: () => Effect.Effect<ExtensionInventory, WorkspaceStateReadFailure>;
+    readonly rows: () => Effect.Effect<ReadonlyArray<ReadModelRecordRow>, WorkspaceStateReadFailure>;
+};
+/**
+ * Base workspace mock with no-op defaults for all methods.
+ * Tests should only override the methods they exercise.
+ *
+ * @example
+ * ```ts
+ * const ws = makeBaseWorkspaceMock("/tmp/axm", {
+ *   setSkill: vi.fn(() => Effect.void),
+ * });
+ * ```
+ */
+export declare const makeBaseWorkspaceMock: (axmDir?: string, overrides?: WorkspaceMockOverrides) => WorkspaceMutationsService;
+export declare const TEST_CONTENT_IDENTITY: string & import("effect/Brand").Brand<"SourceHash">;
+export declare const TEST_TREE_INTEGRITY: string & import("effect/Brand").Brand<"TreeIntegrity">;
+export interface WriteWorkspaceFilesOptions {
+    readonly agents?: ReadonlyArray<string> | undefined;
+    readonly owner?: string | undefined;
+    readonly skills?: Record<string, unknown> | undefined;
+    readonly mcps?: Record<string, unknown> | undefined;
+    readonly subagents?: Record<string, unknown> | undefined;
+    readonly rules?: Record<string, unknown> | undefined;
+    readonly packs?: Record<string, unknown> | undefined;
+    readonly sources?: ReadonlyArray<unknown> | undefined;
+    readonly lockfileSkills?: Record<string, unknown> | undefined;
+    readonly lockfileMcpServers?: Record<string, unknown> | undefined;
+    readonly lockfileSubagents?: Record<string, unknown> | undefined;
+    readonly lockfileRules?: Record<string, unknown> | undefined;
+    readonly lockfilePacks?: Record<string, unknown> | undefined;
+}
+export declare const writeWorkspaceFiles: (runtimeDir: string, opts?: WriteWorkspaceFilesOptions) => void;
+export declare const makeLocalSkillLockEntry: (opts?: {
+    readonly path?: string;
+    readonly agents?: ReadonlyArray<string>;
+    readonly installedAt?: unknown;
+    readonly updatedAt?: unknown;
+}) => SkillLockEntry;
+export declare const makeRegistrySkillLockEntry: (opts: {
+    readonly owner: Handle;
+    readonly name: string;
+    readonly resolvedVersion?: Version;
+    readonly integrity?: string;
+    readonly sourceName?: string;
+    readonly endpoint?: URL;
+    readonly publisherBindingId?: string;
+    readonly agents?: ReadonlyArray<string>;
+    readonly installedAt?: unknown;
+    readonly updatedAt?: unknown;
+}) => SkillLockEntry;
+export declare const makeRegistryMcpServerLockEntry: (opts: {
+    readonly owner: Handle;
+    readonly name: string;
+    readonly resolvedVersion?: Version;
+    readonly integrity?: string;
+    readonly sourceName?: string;
+    readonly endpoint?: URL;
+    readonly publisherBindingId?: string;
+    readonly installedAt?: unknown;
+    readonly updatedAt?: unknown;
+}) => McpServerLockEntry;
+export declare const makeRegistryPackLockEntry: (opts: {
+    readonly owner: Handle;
+    readonly name: string;
+    readonly resolvedVersion?: Version;
+    readonly integrity?: string;
+    readonly sourceName?: string;
+    readonly endpoint?: URL;
+    readonly publisherBindingId?: string;
+    readonly sourceHash?: string;
+    readonly resolvedSkills?: Readonly<Record<string, unknown>>;
+    readonly resolvedMcpServers?: Readonly<Record<string, unknown>>;
+    readonly resolvedSubagents?: Readonly<Record<string, unknown>>;
+    readonly installedAt?: unknown;
+    readonly updatedAt?: unknown;
+}) => RegistryPackLockEntry;
+export {};
+//# sourceMappingURL=test-stubs.d.ts.map