@agentxm/workspace-state 0.28.12 → 0.28.13

package/dist/src/workspace/extension-paths-service.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Extension paths: where the selected scope keeps a skill's or Pack's
+ * canonical content. Skill directories for Registry sources follow the
+ * immutable Registry name, resolved from the accepted lock entry, then the
+ * configured source, then the name given; every other source uses the shared
+ * acquired-extensions directory.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as ServiceMap from "effect/Context";
+import * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import type { Handle } from "@agentxm/extension-model/unstable/extensions/handle";
+import { LockedSkillMissing } from "./errors.js";
+import { LockfileReader, type LockfileReaderService } from "./lockfile-reader.js";
+import { WorkspaceLocation, type WorkspaceLocationService } from "./location.js";
+import type { PackDirPath, SkillDirPaths, SkillPathSource, WorkspaceStateReadFailure } from "./service-interface.js";
+import { SettingsReader, type SettingsReaderService } from "./settings-reader.js";
+export interface ExtensionPathsService {
+    /** Skill directory paths. Without a source, the accepted lock entry decides the layout. */
+    readonly skillDir: (name: string, source?: SkillPathSource) => Effect.Effect<SkillDirPaths, WorkspaceStateReadFailure | LockedSkillMissing, FileSystem.FileSystem | Path.Path>;
+    /** The Pack directory path. Packs are always registry-sourced. */
+    readonly packDir: (name: string, owner: Handle, sourceName: string) => Effect.Effect<PackDirPath, never, Path.Path>;
+}
+declare const ExtensionPaths_base: ServiceMap.ServiceClass<ExtensionPaths, "@agentxm/workspace-state/ExtensionPaths", ExtensionPathsService>;
+export declare class ExtensionPaths extends ExtensionPaths_base {
+}
+export declare const makeExtensionPaths: (location: WorkspaceLocationService, settings: SettingsReaderService, lockfile: LockfileReaderService) => ExtensionPathsService;
+export declare const ExtensionPathsLive: Layer.Layer<ExtensionPaths, never, WorkspaceLocation | SettingsReader | LockfileReader>;
+export {};
+//# sourceMappingURL=extension-paths-service.d.ts.map

package/dist/src/workspace/extension-paths-service.js

@@ -0,0 +1,133 @@
+/**
+ * Extension paths: where the selected scope keeps a skill's or Pack's
+ * canonical content. Skill directories for Registry sources follow the
+ * immutable Registry name, resolved from the accepted lock entry, then the
+ * configured source, then the name given; every other source uses the shared
+ * acquired-extensions directory.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as ServiceMap from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as Ref from "effect/Ref";
+import { parseSourceQualifiedRegistrySourcePatternParts } from "@agentxm/extension-model/unstable/extensions";
+import { LockedSkillMissing } from "./errors.js";
+import { sanitizeName } from "./extension-name.js";
+import { LockfileReader } from "./lockfile-reader.js";
+import { WorkspaceLocation } from "./location.js";
+import { computePackPathsForLayout } from "./pack-paths.js";
+import { SettingsReader } from "./settings-reader.js";
+import { computeSkillPathsForLayout } from "./skill-paths.js";
+export class ExtensionPaths extends ServiceMap.Service()("@agentxm/workspace-state/ExtensionPaths") {
+}
+export const makeExtensionPaths = (location, settings, lockfile) => {
+    /**
+     * Resolve the immutable registry name for a skill's directory: the lockfile
+     * first, then the configured source string, then the given name (correct
+     * for fresh installs).
+     */
+    const resolveRegistryDirName = (name) => Effect.gen(function* () {
+        const lockEntry = yield* lockfile.entry("skill", name);
+        if (Option.isSome(lockEntry) && lockEntry.value.type === "registry") {
+            return lockEntry.value.name;
+        }
+        const entry = (yield* settings.entries("skill"))[name];
+        if (entry !== undefined) {
+            const parsed = parseSourceQualifiedRegistrySourcePatternParts(entry.source);
+            if (parsed?.name !== undefined)
+                return parsed.name;
+        }
+        return name;
+    });
+    return {
+        skillDir: (name, source) => Effect.gen(function* () {
+            const path = yield* Path.Path;
+            const layout = yield* Ref.get(location.layout);
+            if (source !== undefined) {
+                const dirName = source.refType === "registry" ? yield* resolveRegistryDirName(name) : name;
+                return computeSkillPathsForLayout(path.join, layout, source, sanitizeName(dirName));
+            }
+            const lockEntry = yield* lockfile.entry("skill", name);
+            if (Option.isNone(lockEntry)) {
+                return yield* new LockedSkillMissing({ name });
+            }
+            const entry = lockEntry.value;
+            const entrySource = (() => {
+                switch (entry.type) {
+                    case "registry":
+                        return {
+                            refType: "registry",
+                            owner: entry.owner,
+                            source: {
+                                type: "registry",
+                                name: entry.sourceName,
+                                location: entry.endpoint,
+                                owner: Option.some(entry.owner),
+                            },
+                        };
+                    case "local":
+                        return {
+                            refType: "local",
+                            source: { type: "local", path: entry.path },
+                            sourcePath: entry.path,
+                        };
+                    case "github":
+                    case "gitlab":
+                    case "bitbucket":
+                        return {
+                            refType: "git-hosted",
+                            source: {
+                                type: entry.type,
+                                name: entry.sourceName,
+                                url: entry.endpoint,
+                                owner: entry.owner,
+                                repo: entry.repo,
+                                ref: Option.fromUndefinedOr(entry.ref),
+                                subPath: Option.fromUndefinedOr(entry.path),
+                            },
+                            ...(entry.path === undefined ? {} : { sourcePath: entry.path }),
+                        };
+                    case "azurerepos":
+                        return {
+                            refType: "git-hosted",
+                            source: {
+                                type: "azurerepos",
+                                name: entry.sourceName,
+                                url: entry.endpoint,
+                                organization: entry.organization,
+                                project: entry.project,
+                                repo: entry.repo,
+                                ref: Option.fromUndefinedOr(entry.ref),
+                                subPath: Option.fromUndefinedOr(entry.path),
+                            },
+                            ...(entry.path === undefined ? {} : { sourcePath: entry.path }),
+                        };
+                    case "git":
+                        return {
+                            refType: "git-hosted",
+                            source: {
+                                type: "git",
+                                url: new URL(entry.url),
+                                ref: Option.fromUndefinedOr(entry.ref),
+                            },
+                            ...(entry.path === undefined ? {} : { sourcePath: entry.path }),
+                        };
+                }
+            })();
+            const dirName = entry.type === "registry" ? entry.name : entry.packageName;
+            return computeSkillPathsForLayout(path.join, layout, entrySource, sanitizeName(dirName));
+        }),
+        packDir: (name, owner, sourceName) => Effect.gen(function* () {
+            const path = yield* Path.Path;
+            const layout = yield* Ref.get(location.layout);
+            return computePackPathsForLayout(path.join, layout, sourceName, owner, name);
+        }),
+    };
+};
+export const ExtensionPathsLive = Layer.effect(ExtensionPaths, Effect.gen(function* () {
+    return makeExtensionPaths(yield* WorkspaceLocation, yield* SettingsReader, yield* LockfileReader);
+}));
+//# sourceMappingURL=extension-paths-service.js.map

package/dist/src/workspace/location.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Workspace location: the resolved identity of the selected workspace scope.
+ *
+ * One value per workspace lifetime naming the scope, its runtime state
+ * directory, the two shared authoritative files, the project and user
+ * runtime directories both settings sources live in, and the resolved
+ * layout. The layout is a `Ref` because recording an owner replaces it for
+ * the resolution that follows in the same run; only `SettingsWriter.setOwner`
+ * updates it. Every narrow state service reads its paths from here.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as ServiceMap from "effect/Context";
+import * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Ref from "effect/Ref";
+import type { WorkspaceScope } from "@agentxm/extension-model/unstable/workspace-scope";
+import { type SourceHostConfig } from "../settings/index.js";
+import { type WorkspaceLayout } from "./layout.js";
+import type { WorkspaceMutationsError, WorkspaceMutationsOptions } from "./service-interface.js";
+import { type StateCellPaths } from "./state-cells.js";
+export interface WorkspaceLocationService extends StateCellPaths {
+    /** Whether this is the user workspace or a project workspace. */
+    readonly scope: WorkspaceScope;
+    /** User home or project root that anchors scope resolution. */
+    readonly baseDir: string;
+    /** The selected scope's runtime `.axm` directory. */
+    readonly runtimeDir: string;
+    readonly settingsPath: string;
+    readonly lockPath: string;
+    /** The resolved layout; replaced only when an owner is recorded. */
+    readonly layout: Ref.Ref<WorkspaceLayout>;
+    /** Built-in source hosts merged behind project and user settings. */
+    readonly builtInSources: ReadonlyArray<SourceHostConfig>;
+}
+declare const WorkspaceLocation_base: ServiceMap.ServiceClass<WorkspaceLocation, "@agentxm/workspace-state/WorkspaceLocation", WorkspaceLocationService>;
+export declare class WorkspaceLocation extends WorkspaceLocation_base {
+}
+/**
+ * Resolve the workspace location from an existing workspace on disk.
+ *
+ * The workspace must already be initialized unless `allowUninitialized` is
+ * set. Missing or invalid settings and invalid or unsupported lockfiles fail
+ * fast with a typed `WorkspaceMutationsError`.
+ */
+export declare const makeWorkspaceLocation: (options: WorkspaceMutationsOptions) => Effect.Effect<WorkspaceLocationService, WorkspaceMutationsError, FileSystem.FileSystem | Path.Path>;
+export {};
+//# sourceMappingURL=location.d.ts.map

package/dist/src/workspace/location.js

@@ -0,0 +1,85 @@
+/**
+ * Workspace location: the resolved identity of the selected workspace scope.
+ *
+ * One value per workspace lifetime naming the scope, its runtime state
+ * directory, the two shared authoritative files, the project and user
+ * runtime directories both settings sources live in, and the resolved
+ * layout. The layout is a `Ref` because recording an owner replaces it for
+ * the resolution that follows in the same run; only `SettingsWriter.setOwner`
+ * updates it. Every narrow state service reads its paths from here.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as ServiceMap from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as Ref from "effect/Ref";
+import { createDefaultSettings } from "../settings/index.js";
+import { WorkspaceNotInitialized } from "./errors.js";
+import { resolveProjectWorkspaceLayout, resolveProjectWorkspaceStatePaths, resolveUserWorkspaceLayout, } from "./layout.js";
+import { getProjectRuntimeDir, resolveUserHome } from "./paths.js";
+import { LockfileVersionUnsupported } from "./read-model/errors.js";
+import { readLockfileCell, readSettingsCell } from "./state-cells.js";
+export class WorkspaceLocation extends ServiceMap.Service()("@agentxm/workspace-state/WorkspaceLocation") {
+}
+const requireInitializedWorkspace = (settingsPath, settings, lockfile) => settings.pipe(Effect.flatMap(Option.match({
+    onNone: () => lockfile.pipe(Effect.matchEffect({
+        onFailure: (error) => error instanceof LockfileVersionUnsupported &&
+            error.observedVersion > error.supportedVersion
+            ? Effect.fail(error)
+            : Effect.fail(new WorkspaceNotInitialized({ settingsPath })),
+        onSuccess: () => Effect.fail(new WorkspaceNotInitialized({ settingsPath })),
+    })),
+    onSome: () => Effect.void,
+})));
+const defaultBuiltInSources = [
+    { name: "github", type: "github", url: new URL("https://github.com") },
+    { name: "gitlab", type: "gitlab", url: new URL("https://gitlab.com") },
+    { name: "bitbucket", type: "bitbucket", url: new URL("https://bitbucket.org") },
+];
+/**
+ * Resolve the workspace location from an existing workspace on disk.
+ *
+ * The workspace must already be initialized unless `allowUninitialized` is
+ * set. Missing or invalid settings and invalid or unsupported lockfiles fail
+ * fast with a typed `WorkspaceMutationsError`.
+ */
+export const makeWorkspaceLocation = (options) => Effect.gen(function* () {
+    const path = yield* Path.Path;
+    const userHome = yield* resolveUserHome();
+    const initialUserLayout = yield* resolveUserWorkspaceLayout(userHome);
+    const userRuntimeDir = initialUserLayout.runtimeDir;
+    const projectRuntimeDir = yield* getProjectRuntimeDir(options.projectRoot);
+    const runtimeDir = options.scope === "user" ? userRuntimeDir : projectRuntimeDir;
+    const initialProjectState = resolveProjectWorkspaceStatePaths(path, options.projectRoot);
+    const settingsPath = options.scope === "user" ? initialUserLayout.settingsPath : initialProjectState.settingsPath;
+    const lockPath = options.scope === "user" ? initialUserLayout.lockPath : initialProjectState.lockPath;
+    const baseDir = options.scope === "user" ? userHome : options.projectRoot;
+    const cells = {
+        scope: options.scope,
+        projectRoot: options.projectRoot,
+        userHome,
+        projectRuntimeDir,
+        userRuntimeDir,
+    };
+    if (options.allowUninitialized !== true) {
+        yield* requireInitializedWorkspace(settingsPath, readSettingsCell(cells, runtimeDir), readLockfileCell(cells, runtimeDir));
+        yield* readLockfileCell(cells, runtimeDir);
+    }
+    const projectSettings = yield* readSettingsCell(cells, projectRuntimeDir, "project").pipe(Effect.map(Option.getOrElse(() => createDefaultSettings())));
+    const userSettings = yield* readSettingsCell(cells, userRuntimeDir, "user").pipe(Effect.map(Option.getOrElse(() => createDefaultSettings())));
+    const projectLayout = yield* resolveProjectWorkspaceLayout(options.projectRoot, projectSettings);
+    const userLayout = yield* resolveUserWorkspaceLayout(userHome, userSettings);
+    const layout = yield* Ref.make(options.scope === "project" ? projectLayout : userLayout);
+    return {
+        ...cells,
+        baseDir,
+        runtimeDir,
+        settingsPath,
+        lockPath,
+        layout,
+        builtInSources: options.builtInSources ?? defaultBuiltInSources,
+    };
+});
+//# sourceMappingURL=location.js.map

package/dist/src/workspace/lockfile-reader.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Lockfile reader: the selected scope's accepted resolutions — the lockfile
+ * health probe, the per-type entry maps, one entry by name, and the shared
+ * MCP resolution a local connection name accepts.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as ServiceMap from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import type * as Path from "effect/Path";
+import type { InstallableExtensionType } from "@agentxm/extension-model/unstable/extensions/installable-types";
+import { LockfileValidationError } from "../lockfile/errors.js";
+import type { Lockfile, McpServerLockEntry } from "../lockfile/schema.js";
+import { DesiredStateReader, type DesiredStateReaderService } from "./desired-state-reader.js";
+import { type LockEntriesOf, type LockEntryByType } from "./entry-accessors.js";
+import { WorkspaceLocation, type WorkspaceLocationService } from "./location.js";
+import type { WorkspaceRootEscape } from "./read-model/errors.js";
+import type { LockfileState, WorkspaceLockfileReadFailure, WorkspaceStateReadFailure } from "./service-interface.js";
+type Read<A> = Effect.Effect<A, WorkspaceLockfileReadFailure, FileSystem.FileSystem | Path.Path>;
+export interface LockfileReaderService {
+    /** The selected scope's lockfile, empty when the file is absent. */
+    readonly lockfile: Read<Lockfile>;
+    /** Probe lockfile health without mutating disk: ok | missing | invalid. */
+    readonly state: Effect.Effect<LockfileState, LockfileValidationError | WorkspaceRootEscape, FileSystem.FileSystem | Path.Path>;
+    /** The accepted entries of one type, defaulting to `{}`. */
+    readonly entries: <T extends InstallableExtensionType>(type: T) => Read<LockEntriesOf<T>>;
+    /** One accepted entry by its lock key (the workspace name, or the MCP resolution key). */
+    readonly entry: <T extends InstallableExtensionType>(type: T, name: string) => Read<Option.Option<LockEntryByType[T]>>;
+    /** Resolve a local MCP connection name to its shared accepted resolution. */
+    readonly mcpServerForConnection: (localName: string) => Effect.Effect<Option.Option<McpServerLockEntry>, WorkspaceStateReadFailure, FileSystem.FileSystem | Path.Path>;
+}
+declare const LockfileReader_base: ServiceMap.ServiceClass<LockfileReader, "@agentxm/workspace-state/LockfileReader", LockfileReaderService>;
+export declare class LockfileReader extends LockfileReader_base {
+}
+export declare const makeLockfileReader: (location: WorkspaceLocationService, desiredState: DesiredStateReaderService) => LockfileReaderService;
+export declare const LockfileReaderLive: Layer.Layer<LockfileReader, never, WorkspaceLocation | DesiredStateReader>;
+export {};
+//# sourceMappingURL=lockfile-reader.d.ts.map

package/dist/src/workspace/lockfile-reader.js

@@ -0,0 +1,54 @@
+/**
+ * Lockfile reader: the selected scope's accepted resolutions — the lockfile
+ * health probe, the per-type entry maps, one entry by name, and the shared
+ * MCP resolution a local connection name accepts.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as ServiceMap from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { LockfileValidationError } from "../lockfile/errors.js";
+import { DesiredStateReader } from "./desired-state-reader.js";
+import { lockEntries } from "./entry-accessors.js";
+import { WorkspaceLocation } from "./location.js";
+import { readLockfileCell } from "./state-cells.js";
+export class LockfileReader extends ServiceMap.Service()("@agentxm/workspace-state/LockfileReader") {
+}
+export const makeLockfileReader = (location, desiredState) => {
+    const lockfile = readLockfileCell(location, location.runtimeDir);
+    return {
+        lockfile,
+        state: Effect.gen(function* () {
+            const fs = yield* FileSystem.FileSystem;
+            const exists = yield* fs
+                .exists(location.lockPath)
+                .pipe(Effect.mapError((cause) => new LockfileValidationError({ path: location.lockPath, step: "probe", cause })));
+            if (!exists)
+                return "missing";
+            // An unreadable or corrupt lockfile is actionable workspace state, not
+            // a violated invariant.
+            return yield* lockfile.pipe(Effect.as("ok"), Effect.catchTag([
+                "LockfileIoError",
+                "LockfileParseError",
+                "LockfileDecodeError",
+                "LockfileVersionUnsupported",
+            ], () => Effect.succeed("invalid")));
+        }).pipe(Effect.withSpan("LockfileReader.state")),
+        entries: (type) => lockfile.pipe(Effect.map((value) => lockEntries[type].entries(value))),
+        entry: (type, name) => lockfile.pipe(Effect.map((value) => lockEntries[type].entry(value, name))),
+        mcpServerForConnection: (localName) => Effect.gen(function* () {
+            const graph = yield* desiredState.graph();
+            const node = graph.nodes.find((candidate) => candidate.type === "mcp-server" && candidate.name === localName);
+            if (node === undefined || node.authority === "inline")
+                return Option.none();
+            return lockEntries["mcp-server"].entry(yield* lockfile, node.identity);
+        }),
+    };
+};
+export const LockfileReaderLive = Layer.effect(LockfileReader, Effect.gen(function* () {
+    return makeLockfileReader(yield* WorkspaceLocation, yield* DesiredStateReader);
+}));
+//# sourceMappingURL=lockfile-reader.js.map

package/dist/src/workspace/materialized-file-target.d.ts

@@ -2,8 +2,8 @@ import * as Schema from "effect/Schema";
 /**
  * Ephemeral result of one Rule or Hook projection reconciliation. This is the
  * extensibility axis for placement and materialization mode; grammar-level
- * changes belong to the managed-file ownership contract referenced by
- * `projection/marker-grammar.ts`.
+ * changes belong to the managed-file ownership contract implemented by
+ * `@agentxm/agent-integration` `managed-markers.ts`.
  */
 export declare const MaterializedFileTargetSchema: Schema.Struct<{
     readonly target: Schema.brand<Schema.String, "RelativePath">;

package/dist/src/workspace/materialized-file-target.js

@@ -3,8 +3,8 @@ import { RelativePathSchema } from "@agentxm/extension-model/unstable/path-types
 /**
  * Ephemeral result of one Rule or Hook projection reconciliation. This is the
  * extensibility axis for placement and materialization mode; grammar-level
- * changes belong to the managed-file ownership contract referenced by
- * `projection/marker-grammar.ts`.
+ * changes belong to the managed-file ownership contract implemented by
+ * `@agentxm/agent-integration` `managed-markers.ts`.
  */
 export const MaterializedFileTargetSchema = Schema.Struct({
     target: RelativePathSchema,

package/dist/src/workspace/other-scope-reader.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The unselected scope's state, read through the same read model.
+ *
+ * A command that runs against one scope sometimes has to say something true
+ * about the other one — which extensions of the same name the user scope also
+ * configures, for instance. That read belongs to workspace state, which owns
+ * both layouts and both document formats; callers never open those files
+ * themselves.
+ *
+ * The other scope may not exist, or may be unreadable, and neither is a
+ * failure: the answer is simply not determined.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+import type * as Path from "effect/Path";
+import type { WorkspaceScope } from "@agentxm/extension-model/unstable/workspace-scope";
+import type { Lockfile } from "../lockfile/schema.js";
+import type { Settings } from "../settings/index.js";
+import { WorkspaceLocation } from "./location.js";
+export interface OtherScopeState {
+    /** The scope that was inspected: the one this workspace did not select. */
+    readonly scope: WorkspaceScope;
+    readonly settings: Settings;
+    readonly lockfile: Lockfile;
+}
+/**
+ * The settings and lockfile of the scope this workspace did not select, or
+ * `None` when that scope has no readable state.
+ */
+export declare const readOtherScopeState: Effect.Effect<Option.Option<OtherScopeState>, never, WorkspaceLocation | FileSystem.FileSystem | Path.Path>;
+//# sourceMappingURL=other-scope-reader.d.ts.map

package/dist/src/workspace/other-scope-reader.js

@@ -0,0 +1,35 @@
+/**
+ * The unselected scope's state, read through the same read model.
+ *
+ * A command that runs against one scope sometimes has to say something true
+ * about the other one — which extensions of the same name the user scope also
+ * configures, for instance. That read belongs to workspace state, which owns
+ * both layouts and both document formats; callers never open those files
+ * themselves.
+ *
+ * The other scope may not exist, or may be unreadable, and neither is a
+ * failure: the answer is simply not determined.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { WorkspaceLocation } from "./location.js";
+import { readSettingsCell, readLockfileCell } from "./state-cells.js";
+/**
+ * The settings and lockfile of the scope this workspace did not select, or
+ * `None` when that scope has no readable state.
+ */
+export const readOtherScopeState = Effect.gen(function* () {
+    const location = yield* WorkspaceLocation;
+    const scope = location.scope === "project" ? "user" : "project";
+    const dir = scope === "user" ? location.userRuntimeDir : location.projectRuntimeDir;
+    const settings = yield* readSettingsCell(location, dir, scope).pipe(Effect.orElseSucceed(() => Option.none()));
+    if (Option.isNone(settings))
+        return Option.none();
+    const lockfile = yield* readLockfileCell(location, dir, scope).pipe(Effect.result);
+    return lockfile._tag === "Failure"
+        ? Option.none()
+        : Option.some({ scope, settings: settings.value, lockfile: lockfile.success });
+}).pipe(Effect.withSpan("WorkspaceState.readOtherScopeState"));
+//# sourceMappingURL=other-scope-reader.js.map

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

@@ -4,7 +4,7 @@ import * as Path from "effect/Path";
 import { type AbsolutePath } from "@agentxm/extension-model/unstable/path-types";
 import type { WorkspaceScope } from "@agentxm/extension-model/unstable/workspace-scope";
 export { AXM_DIR_NAME, USER_WORKSPACE_DIRECTORY } from "./constants.js";
-export interface WorkspaceLocation {
+export interface LocatedWorkspace {
     readonly scope: WorkspaceScope;
     readonly path: AbsolutePath;
     readonly baseDir: AbsolutePath;
@@ -20,5 +20,5 @@ export declare const resolveUserHome: () => Effect.Effect<AbsolutePath, never, P
 export declare const resolveUserAxmHome: () => Effect.Effect<AbsolutePath, never, Path.Path>;
 export declare const resolveUserWorkspaceRoot: () => Effect.Effect<AbsolutePath, never, Path.Path>;
 export declare const getProjectRuntimeDir: (projectRoot: AbsolutePath) => Effect.Effect<AbsolutePath, never, Path.Path>;
-export declare const locateWorkspace: (scope: WorkspaceScope, projectRoot: AbsolutePath) => Effect.Effect<WorkspaceLocation, never, Path.Path>;
+export declare const locateWorkspace: (scope: WorkspaceScope, projectRoot: AbsolutePath) => Effect.Effect<LocatedWorkspace, never, Path.Path>;
 //# sourceMappingURL=paths.d.ts.map

package/dist/src/workspace/read-model/__fixtures__/test-layer.d.ts

@@ -18,7 +18,7 @@ import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Path from "effect/Path";
 import { AgentRootResolver } from "../agent-root-resolver.js";
-import { AgentPresenceProbe, type AgentPresenceProbeService } from "../agent-presence.js";
+import { AgentPresenceProbe, type AgentPresenceProbeService } from "@agentxm/agent-integration";
 import { WorkspaceReadModelConfig } from "../service.js";
 import { type FixtureSpec, type PathEscapeError } from "./builder.js";
 /**

package/dist/src/workspace/read-model/__fixtures__/test-layer.js

@@ -20,7 +20,7 @@ import * as Layer from "effect/Layer";
 import * as Path from "effect/Path";
 import { makeAbsolutePath } from "@agentxm/extension-model/unstable/path-types";
 import { AgentRootResolver, AgentRootResolverLive } from "../agent-root-resolver.js";
-import { AgentPresenceProbe } from "../agent-presence.js";
+import { AgentPresenceProbe } from "@agentxm/agent-integration";
 import { WorkspaceReadModelConfig } from "../service.js";
 import { buildFixture } from "./builder.js";
 /**

package/dist/src/workspace/read-model/discovery/skills.d.ts

@@ -8,7 +8,7 @@
  */
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
-import type { Skill } from "@agentxm/registry-protocol/unstable/content/skill-types";
+import type { Skill } from "@agentxm/extension-content";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { SkillDiscoveryRootInvalid } from "../errors.js";

package/dist/src/workspace/read-model/discovery/skills.js

@@ -11,7 +11,7 @@ import * as Path from "effect/Path";
 import { AGENTS } from "@agentxm/extension-model/unstable/agents/registry";
 import { AGENT_IDS } from "@agentxm/extension-model/unstable/agents/types";
 import { parsePluginManifests } from "./plugin-manifests.js";
-import { parseSkillMd } from "@agentxm/registry-protocol/unstable/content/skill-content";
+import { parseSkillMd } from "@agentxm/extension-content";
 import * as Array from "effect/Array";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";

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

@@ -33,8 +33,8 @@ import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
 import { decodeExtensionNameSync, ExtensionNameSchema, ExtensionTypeSchema, } from "@agentxm/extension-model/unstable/extensions/common";
 import { HandleSchema } from "@agentxm/extension-model/unstable/extensions/handle";
-import { MANIFEST_FILENAME_BY_TYPE } from "@agentxm/registry-protocol/unstable/publish/manifest-policy";
-import { parseSkillMd } from "@agentxm/registry-protocol/unstable/content/skill-content";
+import { MANIFEST_FILENAME_BY_TYPE } from "@agentxm/extension-content";
+import { parseSkillMd } from "@agentxm/extension-content";
 import { DISCOVERY_SKIPPED_DIRECTORIES } from "@agentxm/extension-model/unstable/discovery-walk";
 import { makeAbsolutePath } from "@agentxm/extension-model/unstable/path-types";
 import { childEntries, fileExists, filterDirectories, splitAbsolutePathSegments, } from "./fs-helpers.js";

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

@@ -30,7 +30,7 @@ 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";
+import { isPathSafe } from "@agentxm/extension-model/unstable/path-types";
 const SCANNER_NAME = "mcp-config";
 /**
  * Closure helper: returns the dependency-closed scanner effect.

package/dist/src/workspace/read-model/service.js

@@ -8,7 +8,7 @@ import * as Path from "effect/Path";
 import * as Ref from "effect/Ref";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
-import { AgentPresenceProbe } from "./agent-presence.js";
+import { AgentPresenceProbe } from "@agentxm/agent-integration";
 import { AGENTS } from "@agentxm/extension-model/unstable/agents/registry";
 import { parseExtensionFqnParts, } from "@agentxm/extension-model/unstable/extensions/common";
 import {} from "@agentxm/extension-model/unstable/extensions/handle";

package/dist/src/workspace/read-model-record-readers.js

@@ -7,7 +7,7 @@
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import { installableExtensionTypes, } from "@agentxm/extension-model/unstable/extensions/installable-types";
-import { isAxmManagedMcpEntry } from "./mcp-entry-semantics.js";
+import { isAxmManagedMcpEntry } from "@agentxm/agent-integration";
 import { createDefaultSettings } from "../settings/index.js";
 import { configuredAgentLifecycleOutcomes } from "./configured-agent-outcomes.js";
 import { projectExtensionInventory, } from "./read-model/extensions/inventory.js";

package/dist/src/workspace/remove-if-exists.d.ts

@@ -9,5 +9,5 @@ import { CanonicalPathRemovalError } from "./errors.js";
 /**
  * Remove a directory if it exists.
  */
-export declare const removeIfExists: (fsService: FileSystem.FileSystem, dirPath: string) => Effect.Effect<void, import("./transaction.js").WorkspaceSnapshotError | CanonicalPathRemovalError, never>;
+export declare const removeIfExists: (fsService: FileSystem.FileSystem, dirPath: string) => Effect.Effect<void, import("@agentxm/workspace-transactions").WorkspaceSnapshotError | CanonicalPathRemovalError, never>;
 //# sourceMappingURL=remove-if-exists.d.ts.map

package/dist/src/workspace/remove-if-exists.js

@@ -6,8 +6,7 @@
 import * as FileSystem from "effect/FileSystem";
 import * as Effect from "effect/Effect";
 import { CanonicalPathRemovalError } from "./errors.js";
-import { protectWorkspacePath } from "./transaction.js";
-import { recordFootprint } from "./footprint-recorder.js";
+import { protectWorkspacePath, recordFootprint } from "@agentxm/workspace-transactions";
 /**
  * Remove a directory if it exists.
  */