@agentxm/client-core 0.4.5 → 0.5.1

package/dist/src/unstable/workspace/service.js

@@ -1,82 +1,85 @@
 /**
- * Workspace context service implementation.
+ * WorkspaceMutations mutation facade implementation.
  *
  * This is the sole public gateway for all settings and lockfile read/write
- * operations. It calls the I/O functions (`readSettings`, `writeSettings`,
- * `readLockfile`, `writeLockfile`) directly and manages mutation
+ * operations. It reads through `WorkspaceReadModel` and calls the write I/O
+ * functions (`writeSettings`, `writeLockfile`) directly while managing mutation
  * serialization via a single Semaphore(1). No other service should perform
  * settings or lockfile I/O in production; the per-service semaphores in
  * `settings/service.ts` and `lockfile/service.ts` have been removed.
  *
  * Supporting logic is split into focused modules:
- * - `taxonomy-types.ts` — classifier-backed type definitions
  * - `source-metadata.ts` — source metadata derivation helpers
  * - `initialization.ts` — workspace initialization (agent detection, settings creation)
- * - `classifier-records.ts` — classifier row → record map converters
+ * - `read-model-record-converters.ts` — workspace row → record map converters
  *
  * @experimental This API is unstable and may change without notice.
  * @packageDocumentation
  */
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
-import { getAgentById } from "../agents/index.js";
-import * as Array from "effect/Array";
 import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
 import * as Semaphore from "effect/Semaphore";
-import { LOCKFILE_NAME, makeRegistryExtensionPackLockEntry, readLockfile, writeLockfile, } from "../lockfile/index.js";
+import { LOCKFILE_NAME, makeRegistryExtensionPackLockEntry, writeLockfile, } from "../lockfile/index.js";
 import { computeSkillPaths } from "../skills/paths.js";
 import { computeExtensionPackPaths } from "../packs/paths.js";
 import { sanitizeName } from "../extensions/utils.js";
 import { AgentIdSchema, decodeExtensionNameSync, formatFqn, parseFullyQualifiedNameParts, parseRegistrySourcePatternParts, } from "../extensions/index.js";
 import { makeAppError } from "../app-error/index.js";
-import { createDefaultSettings, DEFAULT_PROFILE, readSettings, SETTINGS_FILENAME, writeSettings, } from "../settings/index.js";
+import { createDefaultSettings, SETTINGS_FILENAME, writeSettings, } from "../settings/index.js";
 import { lockEntryToSourceParams, printSourceParams } from "../sources/index.js";
 import { getAxmDir } from "./paths.js";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import { Workspace, } from "./service-interface.js";
-import { classifyExtensions } from "./classifier.js";
-import { discoverSkillsInDir } from "../source-resolution/index.js";
-import { deriveSourceMetaForNonSkill, deriveSourceMetaForPacks, deriveSourceMetaForSkills, } from "./source-metadata.js";
-import { toClassifiedCommandRecord, toClassifiedExtensionRefRecord, toClassifiedSkillRecord, toConfiguredCommandRecord, toConfiguredExternalCommandRecord, toConfiguredExternalExtensionRefRecord, toConfiguredExternalSkillRecord, toConfiguredExtensionRefRecord, toConfiguredSkillRecord, toImplicitCommandRecord, toImplicitExtensionRefRecord, toImplicitSkillRecord, toInstalledCommandRecord, toInstalledExtensionRefRecord, toInstalledSkillRecord, toUnmanagedCommandRecord, toUnmanagedExternalCommandRecord, toUnmanagedExternalExtensionRefRecord, toUnmanagedExternalSkillRecord, toUnmanagedExtensionRefRecord, toUnmanagedSkillRecord, toConfiguredSubagentRecord, toImplicitSubagentRecord, toInstalledSubagentRecord, toClassifiedSubagentRecord, } from "./classifier-records.js";
-/**
- * Collect extension names from pack resolvedExtension maps.
- *
- * Extracts the short name from each FQN key (e.g. "@acme/commands/formatter" -> "formatter")
- * across all pack lockfile entries for the given resolved map key.
- */
-const collectTransitiveNames = (packLockEntries, resolvedKey) => {
-    const names = [];
-    for (const packEntry of Object.values(packLockEntries)) {
-        const resolvedMap = packEntry[resolvedKey];
-        for (const fqn of Object.keys(resolvedMap)) {
-            const parsed = parseFullyQualifiedNameParts(fqn);
-            if (parsed !== undefined) {
-                names.push(parsed.name);
-            }
-        }
+import { AgentRootResolverLive } from "./read-model/agent-root-resolver.js";
+import { makeWorkspaceReadModel, WorkspaceReadModelConfig, } from "./read-model/service.js";
+import { WorkspaceMutations, } from "./service-interface.js";
+import { makeReadModelRecordReaders } from "./read-model-record-readers.js";
+import { toConfiguredCommandRecord, toConfiguredExtensionRefRecord, toConfiguredSkillRecord, toInstalledCommandRecord, toInstalledExtensionRefRecord, toInstalledSkillRecord, toUnmanagedCommandRecord, toUnmanagedExtensionRefRecord, toUnmanagedSkillRecord, toConfiguredSubagentRecord, toInstalledSubagentRecord, } from "./read-model-record-converters.js";
+const createEmptyLockfile = () => ({
+    lockfileVersion: 1,
+    skills: {},
+});
+const contextReadErrorToAppError = (source, error) => makeAppError({
+    code: error._tag === "LockfileParseError" ? "validation" : "internal",
+    message: `Failed to read workspace ${source}`,
+    cause: error,
+});
+const contextCellErrorToAppError = (error) => {
+    switch (error._tag) {
+        case "LockfileIoError":
+        case "LockfileParseError":
+        case "LockfileDecodeError":
+            return contextReadErrorToAppError("lockfile", error);
+        case "SettingsIoError":
+        case "SettingsParseError":
+        case "SettingsDecodeError":
+            return contextReadErrorToAppError("settings", error);
+        case "WorkspaceRootEscape":
+            return contextReadErrorToAppError("workspace", error);
     }
-    return names;
 };
 /**
- * Create workspace context effect.
+ * Create workspace mutations effect.
  *
- * Loads an existing workspace context from disk.
+ * Loads an existing workspace from disk.
  *
  * The workspace must already be initialized. Missing or invalid settings fail
  * fast with an `AppError`.
  *
- * @param options - Workspace layer options
- * @returns Effect yielding WorkspaceContextService
+ * @param options - WorkspaceMutations layer options
+ * @returns Effect yielding WorkspaceMutationsService
  *
  * @internal Not exported from barrel - use layer() for external access
  */
-const requireInitializedWorkspace = (settingsPath, workspaceDir) => readSettings(workspaceDir).pipe(Effect.flatMap(Option.match({
+const requireInitializedWorkspace = (settingsPath, settings) => settings.pipe(Effect.flatMap(Option.match({
     onNone: () => Effect.fail(makeAppError({
-        code: "WORKSPACE_NOT_INITIALIZED",
-        what: `Workspace settings not found: ${settingsPath}`,
-        howToFix: "Run `axm setup` to create the workspace.",
+        code: "internal",
+        message: `Workspace settings not found: ${settingsPath}`,
+        breadcrumbs: [
+            { task: "Recover", description: "Run `axm setup` to create the workspace." },
+        ],
     })),
     onSome: () => Effect.void,
 })));
@@ -89,9 +92,17 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
     const path = yield* Path.Path;
     const semaphore = yield* Semaphore.make(1);
     const settingsPath = path.join(workspaceDir, SETTINGS_FILENAME);
-    yield* requireInitializedWorkspace(settingsPath, workspaceDir).pipe(Effect.provide(Layer.mergeAll(Layer.succeed(FileSystem.FileSystem, fs), Layer.succeed(Path.Path, path))));
     const baseDir = path.dirname(workspaceDir);
     const fsLayer = Layer.mergeAll(Layer.succeed(FileSystem.FileSystem, fs), Layer.succeed(Path.Path, path));
+    const contextEnv = Layer.mergeAll(fsLayer, Layer.succeed(WorkspaceReadModelConfig, {
+        projectRoot: path.dirname(localDir),
+        userHome: path.dirname(globalDir),
+        allowedRoot: "/",
+    }), AgentRootResolverLive.pipe(Layer.provide(fsLayer)));
+    const scopeForDir = (dir) => dir === globalDir ? "user" : "project";
+    const readSettingsCell = (dir) => makeWorkspaceReadModel(scopeForDir(dir)).pipe(Effect.flatMap((readModel) => readModel.state.settings), Effect.provide(contextEnv), Effect.mapError((error) => contextReadErrorToAppError("settings", error)));
+    const readLockfileCell = (dir) => makeWorkspaceReadModel(scopeForDir(dir)).pipe(Effect.flatMap((readModel) => readModel.state.lockfile), Effect.map(Option.getOrElse(createEmptyLockfile)), Effect.provide(contextEnv), Effect.mapError((error) => contextReadErrorToAppError("lockfile", error)));
+    yield* requireInitializedWorkspace(settingsPath, readSettingsCell(workspaceDir));
     // Built-in sources: parameterized via options, falling back to git forges only
     const builtInSources = options.builtInSources ?? [
         { name: "github", type: "github", url: new URL("https://github.com") },
@@ -104,167 +115,56 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
     /**
      * Read settings from a directory, returning default settings if not found.
      */
-    const readSettingsSafe = (dir) => readSettings(dir).pipe(Effect.map(Option.getOrElse(() => createDefaultSettings())), Effect.provide(fsLayer));
+    const readSettingsSafe = (dir) => readSettingsCell(dir).pipe(Effect.map(Option.getOrElse(() => createDefaultSettings())));
     /**
      * Read lockfile from a directory, returning empty lockfile if not found.
      */
-    const readLockfileSafe = (dir) => readLockfile(dir).pipe(Effect.provide(fsLayer));
+    const readLockfileSafe = (dir) => readLockfileCell(dir);
     /**
      * Look up `key` in `record`, failing with an `AppError` when absent.
      */
-    const getEntryOrFail = (record, key, code, what) => key in record && record[key] !== undefined
+    const getEntryOrFail = (record, key, code, message) => key in record && record[key] !== undefined
         ? Effect.succeed(record[key])
-        : Effect.fail(makeAppError({ code, what }));
+        : Effect.fail(makeAppError({ code, message }));
     /**
      * Probe lockfile state without mutating disk.
      */
     const getLockfileState = () => Effect.gen(function* () {
         const lockfilePath = path.join(workspaceDir, LOCKFILE_NAME);
         const exists = yield* fs.exists(lockfilePath).pipe(Effect.mapError((error) => makeAppError({
-            code: "LOCKFILE_PARSE_FAILED",
-            what: `Failed to check if lockfile exists at ${lockfilePath}`,
+            code: "validation",
+            message: `Failed to check if lockfile exists at ${lockfilePath}`,
             cause: error,
         })));
         if (!exists) {
             return "missing";
         }
         return yield* readLockfileSafe(workspaceDir).pipe(Effect.as("ok"), Effect.catch((error) => {
-            if (error.code === "LOCKFILE_PARSE_FAILED" ||
-                error.code === "LOCKFILE_RESOLVED_VERSION_INVALID") {
+            if (error.code === "validation") {
                 return Effect.succeed("invalid");
             }
             return Effect.fail(error);
         }));
-    }).pipe(Effect.withSpan("Workspace.getLockfileState"));
-    // -----------------------------------------------------------------------
-    // Classifier integration
-    // -----------------------------------------------------------------------
-    /**
-     * Detect skill names on disk from configured agent skill directories.
-     */
-    const detectSkillEntriesOnDisk = (agentIds) => Effect.gen(function* () {
-        const agentRoots = Array.getSomes(Array.map(agentIds, (agentId) => Option.map(getAgentById(agentId), (agent) => path.join(baseDir, agent.skills.dir))));
-        const dedupedRoots = Array.dedupe(agentRoots);
-        const discovered = yield* Effect.forEach(dedupedRoots, (agentRoot) => discoverSkillsInDir(agentRoot, Option.none(), {
-            fullDepth: false,
-            includeInternal: false,
-        }).pipe(Effect.catch(() => Effect.succeed([])), Effect.provide(fsLayer)), { concurrency: "unbounded" }).pipe(Effect.map(Array.flatten));
-        // Group locations by name, making them relative to the workspace root (baseDir)
-        const locationsByName = new Map();
-        for (const d of discovered) {
-            const rawLocation = d.location.startsWith("file://")
-                ? d.location.slice("file://".length)
-                : d.location;
-            const relative = path.relative(baseDir, rawLocation);
-            const existing = locationsByName.get(d.skill.name);
-            if (existing) {
-                if (!existing.includes(relative)) {
-                    locationsByName.set(d.skill.name, [...existing, relative]);
-                }
-            }
-            else {
-                locationsByName.set(d.skill.name, [relative]);
-            }
-        }
-        return [...locationsByName.entries()].map(([name, locations]) => ({
-            name,
-            locations,
-        }));
-    });
-    /**
-     * Classify extensions by type using the shared classifier.
-     */
-    const getClassifiedExtensions = (type) => Effect.gen(function* () {
-        const settings = yield* readSettingsSafe(workspaceDir);
-        const lockfile = yield* readLockfileSafe(workspaceDir);
-        switch (type) {
-            case "skill": {
-                const detectedEntries = yield* detectSkillEntriesOnDisk(settings.agents ?? []);
-                const detectedNames = detectedEntries.map((e) => e.name);
-                const configuredSkills = settings.skills ?? {};
-                return yield* classifyExtensions({
-                    type,
-                    configured: configuredSkills,
-                    lockedNames: Object.keys(lockfile.skills),
-                    detectedEntries,
-                    ignoredPatterns: settings.ignored?.skills ?? [],
-                    sourceMetaByName: deriveSourceMetaForSkills(settings, lockfile.skills, detectedNames),
-                });
-            }
-            case "command": {
-                const commandSettings = settings.commands ?? {};
-                const commandLockEntries = lockfile.commands ?? {};
-                // Collect transitive command names from pack resolvedCommands
-                const directLockedNames = Object.keys(commandLockEntries);
-                const transitiveNames = collectTransitiveNames(lockfile.packs ?? {}, "resolvedCommands");
-                const allLockedNames = Array.dedupe([...directLockedNames, ...transitiveNames]);
-                // Build source metadata including transitive commands as native
-                const directSourceMeta = deriveSourceMetaForNonSkill(commandSettings, commandLockEntries);
-                const sourceMetaByName = { ...directSourceMeta };
-                for (const name of transitiveNames) {
-                    if (!(name in sourceMetaByName)) {
-                        sourceMetaByName[name] = { packagingKind: "native" };
-                    }
-                }
-                return yield* classifyExtensions({
-                    type,
-                    configured: commandSettings,
-                    lockedNames: allLockedNames,
-                    detectedEntries: [],
-                    ignoredPatterns: settings.ignored?.commands ?? [],
-                    sourceMetaByName,
-                });
-            }
-            case "mcp-server": {
-                const mcpSettings = settings.mcpServers ?? {};
-                const mcpServerLockEntries = lockfile.mcpServers ?? {};
-                return yield* classifyExtensions({
-                    type,
-                    configured: mcpSettings,
-                    lockedNames: Object.keys(mcpServerLockEntries),
-                    detectedEntries: [],
-                    ignoredPatterns: settings.ignored?.mcpServers ?? [],
-                    sourceMetaByName: deriveSourceMetaForNonSkill(mcpSettings, mcpServerLockEntries),
-                });
-            }
-            case "pack": {
-                const packSettings = settings.packs ?? {};
-                const packLockEntries = lockfile.packs ?? {};
-                return yield* classifyExtensions({
-                    type,
-                    configured: packSettings,
-                    lockedNames: Object.keys(packLockEntries),
-                    detectedEntries: [],
-                    ignoredPatterns: settings.ignored?.packs ?? [],
-                    sourceMetaByName: deriveSourceMetaForPacks(packSettings, packLockEntries),
-                });
-            }
-            case "subagent": {
-                const subagentSettings = settings.subagents ?? {};
-                const subagentLockEntries = lockfile.subagents ?? {};
-                // Collect transitive subagent names from pack resolvedSubagents
-                const directLockedNames = Object.keys(subagentLockEntries);
-                const transitiveNames = collectTransitiveNames(lockfile.packs ?? {}, "resolvedSubagents");
-                const allLockedNames = Array.dedupe([...directLockedNames, ...transitiveNames]);
-                // Build source metadata including transitive subagents as native
-                const directSourceMeta = deriveSourceMetaForNonSkill(subagentSettings, subagentLockEntries);
-                const sourceMetaByName = { ...directSourceMeta };
-                for (const name of transitiveNames) {
-                    if (!(name in sourceMetaByName)) {
-                        sourceMetaByName[name] = { packagingKind: "native" };
-                    }
-                }
-                return yield* classifyExtensions({
-                    type,
-                    configured: subagentSettings,
-                    lockedNames: allLockedNames,
-                    detectedEntries: [],
-                    ignoredPatterns: settings.ignored?.subagents ?? [],
-                    sourceMetaByName,
-                });
-            }
-        }
-    });
+    }).pipe(Effect.withSpan("WorkspaceMutations.getLockfileState"));
+    const readScopedContext = (f) => makeWorkspaceReadModel(scopeForDir(workspaceDir)).pipe(Effect.flatMap(f), Effect.provide(contextEnv), Effect.mapError(contextCellErrorToAppError));
+    const readModelRecordReaders = makeReadModelRecordReaders({ baseDir, path, readScopedContext });
+    const getReadModelRecordRows = readModelRecordReaders.getReadModelRecordRows;
+    const records = {
+        getConfiguredSkills: () => getReadModelRecordRows("skill").pipe(Effect.map(toConfiguredSkillRecord)),
+        getUnmanagedSkills: () => getReadModelRecordRows("skill").pipe(Effect.map(toUnmanagedSkillRecord)),
+        getInstalledSkills: () => getReadModelRecordRows("skill").pipe(Effect.map(toInstalledSkillRecord)),
+        getConfiguredCommands: () => getReadModelRecordRows("command").pipe(Effect.map(toConfiguredCommandRecord)),
+        getUnmanagedCommands: () => getReadModelRecordRows("command").pipe(Effect.map(toUnmanagedCommandRecord)),
+        getInstalledCommands: () => getReadModelRecordRows("command").pipe(Effect.map(toInstalledCommandRecord)),
+        getConfiguredMcpServers: () => getReadModelRecordRows("mcp-server").pipe(Effect.map(toConfiguredExtensionRefRecord)),
+        getUnmanagedMcpServers: () => getReadModelRecordRows("mcp-server").pipe(Effect.map(toUnmanagedExtensionRefRecord)),
+        getInstalledMcpServers: () => getReadModelRecordRows("mcp-server").pipe(Effect.map(toInstalledExtensionRefRecord)),
+        getConfiguredPacks: () => getReadModelRecordRows("pack").pipe(Effect.map(toConfiguredExtensionRefRecord)),
+        getUnmanagedPacks: () => getReadModelRecordRows("pack").pipe(Effect.map(toUnmanagedExtensionRefRecord)),
+        getInstalledPacks: () => getReadModelRecordRows("pack").pipe(Effect.map(toInstalledExtensionRefRecord)),
+        getConfiguredSubagents: () => getReadModelRecordRows("subagent").pipe(Effect.map(toConfiguredSubagentRecord)),
+        getInstalledSubagents: () => getReadModelRecordRows("subagent").pipe(Effect.map(toInstalledSubagentRecord)),
+    };
     /**
      * Resolve the immutable registry name for a skill's directory.
      *
@@ -316,7 +216,7 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
         ];
         cachedSources = merged;
         return merged;
-    }).pipe(Effect.withSpan("Workspace.getConfiguredSources"));
+    }).pipe(Effect.withSpan("WorkspaceMutations.getConfiguredSources"));
     return {
         scope: options.scope,
         path: workspaceDir,
@@ -328,23 +228,14 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
             const registrySources = sources.filter((s) => s.type === "registry");
             return registrySources;
         })),
-        getConfiguredProfile: () => Effect.gen(function* () {
+        records,
+        getConfiguredOwner: () => Effect.gen(function* () {
             const projectSettings = yield* readSettingsSafe(localDir);
-            if (projectSettings.profile)
-                return projectSettings.profile;
+            if (projectSettings.owner)
+                return Option.some(projectSettings.owner);
             const globalSettings = yield* readSettingsSafe(globalDir);
-            if (globalSettings.profile)
-                return globalSettings.profile;
-            return DEFAULT_PROFILE;
-        }),
-        // TODO: check logged-in identity handle when auth is implemented
-        getDefaultProfile: () => Effect.gen(function* () {
-            const projectSettings = yield* readSettingsSafe(localDir);
-            if (projectSettings.profile)
-                return Option.some(projectSettings.profile);
-            const globalSettings = yield* readSettingsSafe(globalDir);
-            if (globalSettings.profile)
-                return Option.some(globalSettings.profile);
+            if (globalSettings.owner)
+                return Option.some(globalSettings.owner);
             return Option.none();
         }),
         addConfiguredSource: (source) => withMutex(Effect.gen(function* () {
@@ -353,16 +244,9 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
             const updatedSettings = { ...current, sources: [...currentSources, source] };
             yield* writeSettings(workspaceDir, updatedSettings).pipe(Effect.provide(fsLayer));
             cachedSources = null; // invalidate cache
-        })).pipe(Effect.withSpan("Workspace.addConfiguredSource")),
-        getConfiguredSkills: () => getClassifiedExtensions("skill").pipe(Effect.map(toConfiguredSkillRecord)),
-        getImplicitSkills: () => getClassifiedExtensions("skill").pipe(Effect.map(toImplicitSkillRecord)),
-        getUnmanagedSkills: () => getClassifiedExtensions("skill").pipe(Effect.map(toUnmanagedSkillRecord)),
-        getInstalledSkills: () => getClassifiedExtensions("skill").pipe(Effect.map(toInstalledSkillRecord)),
-        getClassifiedSkills: () => getClassifiedExtensions("skill").pipe(Effect.map(toClassifiedSkillRecord)),
-        getConfiguredExternalSkills: () => getClassifiedExtensions("skill").pipe(Effect.map(toConfiguredExternalSkillRecord)),
-        getUnmanagedExternalSkills: () => getClassifiedExtensions("skill").pipe(Effect.map(toUnmanagedExternalSkillRecord)),
+        })).pipe(Effect.withSpan("WorkspaceMutations.addConfiguredSource")),
         getIgnoredSkillPatterns: () => readSettingsSafe(workspaceDir).pipe(Effect.map((s) => s.ignored?.skills ?? [])),
-        getConfiguredAgents: () => readSettingsSafe(workspaceDir).pipe(Effect.map((s) => s.agents ?? []), Effect.withSpan("Workspace.getConfiguredAgents")),
+        getConfiguredAgents: () => readSettingsSafe(workspaceDir).pipe(Effect.map((s) => s.agents ?? []), Effect.withSpan("WorkspaceMutations.getConfiguredAgents")),
         getLockedSkills: () => readLockfileSafe(workspaceDir).pipe(Effect.map((lf) => lf.skills)),
         getLockedSkill: (name) => readLockfileSafe(workspaceDir).pipe(Effect.map((lf) => Option.fromUndefinedOr(lf.skills[name]))),
         getSkillDir: (name, source) => Effect.gen(function* () {
@@ -373,9 +257,14 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
             const lockEntry = yield* readLockfileSafe(workspaceDir).pipe(Effect.map((lf) => Option.fromUndefinedOr(lf.skills[name])));
             if (Option.isNone(lockEntry)) {
                 return yield* makeAppError({
-                    code: "SKILL_NOT_LOCKED",
-                    what: `Skill "${name}" not found in lockfile`,
-                    howToFix: "Install the skill first with `axm skills install`",
+                    code: "conflict",
+                    message: `Skill "${name}" not found in lockfile`,
+                    breadcrumbs: [
+                        {
+                            task: "Recover",
+                            description: "Install the skill first with `axm skills install`",
+                        },
+                    ],
                 });
             }
             const entry = lockEntry.value;
@@ -404,9 +293,10 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
                 : printSourceParams(sourceInput);
             const currentSettings = yield* readSettingsSafe(workspaceDir);
             const currentSkills = currentSettings.skills ?? {};
+            const authored = currentSkills[name]?.authored ?? false;
             const updatedSettings = {
                 ...currentSettings,
-                skills: { ...currentSkills, [name]: { source, enabled: true } },
+                skills: { ...currentSkills, [name]: { source, enabled: true, authored } },
             };
             yield* writeSettings(workspaceDir, updatedSettings).pipe(Effect.provide(fsLayer));
             // Update lockfile
@@ -422,7 +312,7 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
                 },
             };
             yield* writeLockfile(workspaceDir, updatedLockfile).pipe(Effect.provide(fsLayer));
-        })).pipe(Effect.withSpan("Workspace.setSkill")),
+        })).pipe(Effect.withSpan("WorkspaceMutations.setSkill")),
         setSkillLock: ({ name, lockEntry }) => withMutex(Effect.gen(function* () {
             // Update lockfile only (skip settings) — used for pack dependencies
             const currentLockfile = yield* readLockfileSafe(workspaceDir);
@@ -437,7 +327,7 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
                 },
             };
             yield* writeLockfile(workspaceDir, updatedLockfile).pipe(Effect.provide(fsLayer));
-        })).pipe(Effect.withSpan("Workspace.setSkillLock")),
+        })).pipe(Effect.withSpan("WorkspaceMutations.setSkillLock")),
         removeSkill: (name) => withMutex(Effect.gen(function* () {
             // Update settings
             const currentSettings = yield* readSettingsSafe(workspaceDir);
@@ -458,7 +348,7 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
                 const updatedLockfile = { ...currentLockfile, skills: remainingLockSkills };
                 yield* writeLockfile(workspaceDir, updatedLockfile).pipe(Effect.provide(fsLayer));
             }
-        })).pipe(Effect.withSpan("Workspace.removeSkill")),
+        })).pipe(Effect.withSpan("WorkspaceMutations.removeSkill")),
         removeSkillFromSettings: (name) => withMutex(Effect.gen(function* () {
             const currentSettings = yield* readSettingsSafe(workspaceDir);
             const currentSkills = currentSettings.skills ?? {};
@@ -472,7 +362,7 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
         updateSkillEntry: (name, updater) => withMutex(Effect.gen(function* () {
             const currentSettings = yield* readSettingsSafe(workspaceDir);
             const currentSkills = currentSettings.skills ?? {};
-            const currentEntry = yield* getEntryOrFail(currentSkills, name, "SKILL_NOT_FOUND", `Skill "${name}" not found in settings`);
+            const currentEntry = yield* getEntryOrFail(currentSkills, name, "not_found", `Skill "${name}" not found in settings`);
             const updated = updater(currentEntry);
             const updatedSettings = {
                 ...currentSettings,
@@ -489,34 +379,9 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
             };
             yield* writeSettings(workspaceDir, updatedSettings).pipe(Effect.provide(fsLayer));
         })),
-        renameSkill: (oldName, newName) => withMutex(Effect.gen(function* () {
-            // Read and validate settings
-            const currentSettings = yield* readSettingsSafe(workspaceDir);
-            const currentSkills = currentSettings.skills ?? {};
-            const oldEntry = yield* getEntryOrFail(currentSkills, oldName, "SKILL_NOT_FOUND", `Skill "${oldName}" not found in settings`);
-            const { [oldName]: _, ...remainingSkills } = currentSkills;
-            void _;
-            const updatedSettings = {
-                ...currentSettings,
-                skills: { ...remainingSkills, [newName]: oldEntry },
-            };
-            yield* writeSettings(workspaceDir, updatedSettings).pipe(Effect.provide(fsLayer));
-            // Rename in lockfile if entry exists
-            const currentLockfile = yield* readLockfileSafe(workspaceDir);
-            const oldLockEntry = currentLockfile.skills[oldName];
-            if (oldLockEntry !== undefined) {
-                const { [oldName]: __, ...remainingLockSkills } = currentLockfile.skills;
-                void __;
-                const updatedLockfile = {
-                    ...currentLockfile,
-                    skills: { ...remainingLockSkills, [newName]: oldLockEntry },
-                };
-                yield* writeLockfile(workspaceDir, updatedLockfile).pipe(Effect.provide(fsLayer));
-            }
-        })),
         updateLockEntryAgents: (name, agents) => withMutex(Effect.gen(function* () {
             const currentLockfile = yield* readLockfileSafe(workspaceDir);
-            const oldEntry = yield* getEntryOrFail(currentLockfile.skills, name, "LOCK_ENTRY_NOT_FOUND", `Lock entry "${name}" not found in lockfile`);
+            const oldEntry = yield* getEntryOrFail(currentLockfile.skills, name, "not_found", `Lock entry "${name}" not found in lockfile`);
             const updatedLockfile = {
                 ...currentLockfile,
                 skills: {
@@ -528,8 +393,8 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
         })),
         addConfiguredAgent: (agentId) => withMutex(Effect.gen(function* () {
             const validId = yield* Schema.decodeUnknownEffect(AgentIdSchema)(agentId).pipe(Effect.mapError((error) => makeAppError({
-                code: "SETTINGS_PARSE_FAILED",
-                what: `Invalid agent ID: ${agentId}`,
+                code: "validation",
+                message: `Invalid agent ID: ${agentId}`,
                 cause: error,
             })));
             const current = yield* readSettingsSafe(workspaceDir);
@@ -539,38 +404,8 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
             const updatedSettings = { ...current, agents: [...agents, validId] };
             yield* writeSettings(workspaceDir, updatedSettings).pipe(Effect.provide(fsLayer));
         })),
-        // -----------------------------------------------------------------------
-        // Command taxonomy getters
-        // -----------------------------------------------------------------------
-        getConfiguredCommands: () => getClassifiedExtensions("command").pipe(Effect.map(toConfiguredCommandRecord)),
-        getImplicitCommands: () => getClassifiedExtensions("command").pipe(Effect.map(toImplicitCommandRecord)),
-        getUnmanagedCommands: () => getClassifiedExtensions("command").pipe(Effect.map(toUnmanagedCommandRecord)),
-        getInstalledCommands: () => getClassifiedExtensions("command").pipe(Effect.map(toInstalledCommandRecord)),
-        getClassifiedCommands: () => getClassifiedExtensions("command").pipe(Effect.map(toClassifiedCommandRecord)),
-        getConfiguredExternalCommands: () => getClassifiedExtensions("command").pipe(Effect.map(toConfiguredExternalCommandRecord)),
-        getUnmanagedExternalCommands: () => getClassifiedExtensions("command").pipe(Effect.map(toUnmanagedExternalCommandRecord)),
         getIgnoredCommandPatterns: () => readSettingsSafe(workspaceDir).pipe(Effect.map((s) => s.ignored?.commands ?? [])),
-        // -----------------------------------------------------------------------
-        // MCP Server taxonomy getters
-        // -----------------------------------------------------------------------
-        getConfiguredMcpServers: () => getClassifiedExtensions("mcp-server").pipe(Effect.map(toConfiguredExtensionRefRecord)),
-        getImplicitMcpServers: () => getClassifiedExtensions("mcp-server").pipe(Effect.map(toImplicitExtensionRefRecord)),
-        getUnmanagedMcpServers: () => getClassifiedExtensions("mcp-server").pipe(Effect.map(toUnmanagedExtensionRefRecord)),
-        getInstalledMcpServers: () => getClassifiedExtensions("mcp-server").pipe(Effect.map(toInstalledExtensionRefRecord)),
-        getClassifiedMcpServers: () => getClassifiedExtensions("mcp-server").pipe(Effect.map(toClassifiedExtensionRefRecord)),
-        getConfiguredExternalMcpServers: () => getClassifiedExtensions("mcp-server").pipe(Effect.map(toConfiguredExternalExtensionRefRecord)),
-        getUnmanagedExternalMcpServers: () => getClassifiedExtensions("mcp-server").pipe(Effect.map(toUnmanagedExternalExtensionRefRecord)),
         getIgnoredMcpServerPatterns: () => readSettingsSafe(workspaceDir).pipe(Effect.map((s) => s.ignored?.mcpServers ?? [])),
-        // -----------------------------------------------------------------------
-        // Pack taxonomy getters
-        // -----------------------------------------------------------------------
-        getConfiguredPacks: () => getClassifiedExtensions("pack").pipe(Effect.map(toConfiguredExtensionRefRecord)),
-        getImplicitPacks: () => getClassifiedExtensions("pack").pipe(Effect.map(toImplicitExtensionRefRecord)),
-        getUnmanagedPacks: () => getClassifiedExtensions("pack").pipe(Effect.map(toUnmanagedExtensionRefRecord)),
-        getInstalledPacks: () => getClassifiedExtensions("pack").pipe(Effect.map(toInstalledExtensionRefRecord)),
-        getClassifiedPacks: () => getClassifiedExtensions("pack").pipe(Effect.map(toClassifiedExtensionRefRecord)),
-        getConfiguredExternalPacks: () => getClassifiedExtensions("pack").pipe(Effect.map(toConfiguredExternalExtensionRefRecord)),
-        getUnmanagedExternalPacks: () => getClassifiedExtensions("pack").pipe(Effect.map(toUnmanagedExternalExtensionRefRecord)),
         getIgnoredPackPatterns: () => readSettingsSafe(workspaceDir).pipe(Effect.map((s) => s.ignored?.packs ?? [])),
         getLockedExtensionPacks: () => readLockfileSafe(workspaceDir).pipe(Effect.map((lf) => lf.packs ?? {})),
         getLockedExtensionPack: (name) => readLockfileSafe(workspaceDir).pipe(Effect.map((lf) => Option.fromUndefinedOr((lf.packs ?? {})[name]))),
@@ -591,9 +426,10 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
                 : fqn;
             const currentSettings = yield* readSettingsSafe(workspaceDir);
             const currentPacks = currentSettings.packs ?? {};
+            const authored = currentPacks[name]?.authored ?? false;
             const updatedSettings = {
                 ...currentSettings,
-                packs: { ...currentPacks, [name]: { source } },
+                packs: { ...currentPacks, [name]: { source, authored } },
             };
             yield* writeSettings(workspaceDir, updatedSettings).pipe(Effect.provide(fsLayer));
             // Update lockfile
@@ -610,7 +446,16 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
                 },
             };
             yield* writeLockfile(workspaceDir, updatedLockfile).pipe(Effect.provide(fsLayer));
-        })).pipe(Effect.withSpan("Workspace.setExtensionPack")),
+        })).pipe(Effect.withSpan("WorkspaceMutations.setExtensionPack")),
+        setExtensionPackEntry: (name, entry) => withMutex(Effect.gen(function* () {
+            const currentSettings = yield* readSettingsSafe(workspaceDir);
+            const currentPacks = currentSettings.packs ?? {};
+            const updatedSettings = {
+                ...currentSettings,
+                packs: { ...currentPacks, [name]: entry },
+            };
+            yield* writeSettings(workspaceDir, updatedSettings).pipe(Effect.provide(fsLayer));
+        })).pipe(Effect.withSpan("WorkspaceMutations.setExtensionPackEntry")),
         removeExtensionPack: (name) => withMutex(Effect.gen(function* () {
             // Update settings
             const currentSettings = yield* readSettingsSafe(workspaceDir);
@@ -630,7 +475,7 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
                 const updatedLockfile = { ...currentLockfile, packs: remainingLockedPacks };
                 yield* writeLockfile(workspaceDir, updatedLockfile).pipe(Effect.provide(fsLayer));
             }
-        })).pipe(Effect.withSpan("Workspace.removeExtensionPack")),
+        })).pipe(Effect.withSpan("WorkspaceMutations.removeExtensionPack")),
         getExtensionPackDir: (name, owner) => Effect.succeed(computeExtensionPackPaths(path.join, baseDir, owner, name)),
         // -----------------------------------------------------------------------
         // Command methods
@@ -643,9 +488,10 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
             const source = printSourceParams(sourceInput);
             const currentSettings = yield* readSettingsSafe(workspaceDir);
             const currentCommands = currentSettings.commands ?? {};
+            const authored = currentCommands[name]?.authored ?? false;
             const updatedSettings = {
                 ...currentSettings,
-                commands: { ...currentCommands, [name]: { source, enabled: true } },
+                commands: { ...currentCommands, [name]: { source, enabled: true, authored } },
             };
             yield* writeSettings(workspaceDir, updatedSettings).pipe(Effect.provide(fsLayer));
             // Update lockfile
@@ -662,7 +508,7 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
                 },
             };
             yield* writeLockfile(workspaceDir, updatedLockfile).pipe(Effect.provide(fsLayer));
-        })).pipe(Effect.withSpan("Workspace.setCommand")),
+        })).pipe(Effect.withSpan("WorkspaceMutations.setCommand")),
         setCommandLock: ({ name, lockEntry }) => withMutex(Effect.gen(function* () {
             // Update lockfile only (skip settings) — used for pack dependencies
             const currentLockfile = yield* readLockfileSafe(workspaceDir);
@@ -702,7 +548,7 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
                 };
                 yield* writeLockfile(workspaceDir, updatedLockfile).pipe(Effect.provide(fsLayer));
             }
-        })).pipe(Effect.withSpan("Workspace.removeCommand")),
+        })).pipe(Effect.withSpan("WorkspaceMutations.removeCommand")),
         updateCommandEntry: (name, updater) => withMutex(Effect.gen(function* () {
             const currentSettings = yield* readSettingsSafe(workspaceDir);
             const currentCommands = currentSettings.commands ?? {};
@@ -715,7 +561,7 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
                 commands: { ...currentCommands, [name]: updated },
             };
             yield* writeSettings(workspaceDir, updatedSettings).pipe(Effect.provide(fsLayer));
-        })).pipe(Effect.withSpan("Workspace.updateCommandEntry")),
+        })).pipe(Effect.withSpan("WorkspaceMutations.updateCommandEntry")),
         setCommandEntry: (name, entry) => withMutex(Effect.gen(function* () {
             const currentSettings = yield* readSettingsSafe(workspaceDir);
             const currentCommands = currentSettings.commands ?? {};
@@ -724,14 +570,7 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
                 commands: { ...currentCommands, [name]: entry },
             };
             yield* writeSettings(workspaceDir, updatedSettings).pipe(Effect.provide(fsLayer));
-        })).pipe(Effect.withSpan("Workspace.setCommandEntry")),
-        // -----------------------------------------------------------------------
-        // Subagent taxonomy
-        // -----------------------------------------------------------------------
-        getConfiguredSubagents: () => getClassifiedExtensions("subagent").pipe(Effect.map(toConfiguredSubagentRecord)),
-        getImplicitSubagents: () => getClassifiedExtensions("subagent").pipe(Effect.map(toImplicitSubagentRecord)),
-        getInstalledSubagents: () => getClassifiedExtensions("subagent").pipe(Effect.map(toInstalledSubagentRecord)),
-        getClassifiedSubagents: () => getClassifiedExtensions("subagent").pipe(Effect.map(toClassifiedSubagentRecord)),
+        })).pipe(Effect.withSpan("WorkspaceMutations.setCommandEntry")),
         // -----------------------------------------------------------------------
         // Subagent methods
         // -----------------------------------------------------------------------
@@ -743,9 +582,10 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
             const source = printSourceParams(sourceInput);
             const currentSettings = yield* readSettingsSafe(workspaceDir);
             const currentSubagents = currentSettings.subagents ?? {};
+            const authored = currentSubagents[name]?.authored ?? false;
             const updatedSettings = {
                 ...currentSettings,
-                subagents: { ...currentSubagents, [name]: { source, enabled: true } },
+                subagents: { ...currentSubagents, [name]: { source, enabled: true, authored } },
             };
             yield* writeSettings(workspaceDir, updatedSettings).pipe(Effect.provide(fsLayer));
             // Update lockfile
@@ -762,7 +602,7 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
                 },
             };
             yield* writeLockfile(workspaceDir, updatedLockfile).pipe(Effect.provide(fsLayer));
-        })).pipe(Effect.withSpan("Workspace.setSubagent")),
+        })).pipe(Effect.withSpan("WorkspaceMutations.setSubagent")),
         setSubagentLock: ({ name, lockEntry }) => withMutex(Effect.gen(function* () {
             // Update lockfile only (skip settings) — used for pack dependencies
             const currentLockfile = yield* readLockfileSafe(workspaceDir);
@@ -802,7 +642,7 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
                 };
                 yield* writeLockfile(workspaceDir, updatedLockfile).pipe(Effect.provide(fsLayer));
             }
-        })).pipe(Effect.withSpan("Workspace.removeSubagent")),
+        })).pipe(Effect.withSpan("WorkspaceMutations.removeSubagent")),
         updateSubagentEntry: (name, updater) => withMutex(Effect.gen(function* () {
             const currentSettings = yield* readSettingsSafe(workspaceDir);
             const currentSubagents = currentSettings.subagents ?? {};
@@ -815,7 +655,7 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
                 subagents: { ...currentSubagents, [name]: updated },
             };
             yield* writeSettings(workspaceDir, updatedSettings).pipe(Effect.provide(fsLayer));
-        })).pipe(Effect.withSpan("Workspace.updateSubagentEntry")),
+        })).pipe(Effect.withSpan("WorkspaceMutations.updateSubagentEntry")),
         setSubagentEntry: (name, entry) => withMutex(Effect.gen(function* () {
             const currentSettings = yield* readSettingsSafe(workspaceDir);
             const currentSubagents = currentSettings.subagents ?? {};
@@ -824,7 +664,7 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
                 subagents: { ...currentSubagents, [name]: entry },
             };
             yield* writeSettings(workspaceDir, updatedSettings).pipe(Effect.provide(fsLayer));
-        })).pipe(Effect.withSpan("Workspace.setSubagentEntry")),
+        })).pipe(Effect.withSpan("WorkspaceMutations.setSubagentEntry")),
         removeSubagentSettings: (name) => withMutex(Effect.gen(function* () {
             const currentSettings = yield* readSettingsSafe(workspaceDir);
             const currentSubagents = currentSettings.subagents ?? {};
@@ -844,7 +684,7 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
             void _;
             const updatedLockfile = { ...currentLockfile, subagents: remaining };
             yield* writeLockfile(workspaceDir, updatedLockfile).pipe(Effect.provide(fsLayer));
-        })).pipe(Effect.withSpan("Workspace.removeSubagentLock")),
+        })).pipe(Effect.withSpan("WorkspaceMutations.removeSubagentLock")),
         // -----------------------------------------------------------------------
         // MCP Server methods
         // -----------------------------------------------------------------------
@@ -856,9 +696,10 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
             const source = printSourceParams(sourceInput);
             const currentSettings = yield* readSettingsSafe(workspaceDir);
             const currentMcpServers = currentSettings.mcpServers ?? {};
+            const authored = currentMcpServers[name]?.authored ?? false;
             const updatedSettings = {
                 ...currentSettings,
-                mcpServers: { ...currentMcpServers, [name]: { source } },
+                mcpServers: { ...currentMcpServers, [name]: { source, authored } },
             };
             yield* writeSettings(workspaceDir, updatedSettings).pipe(Effect.provide(fsLayer));
             // Update lockfile (uses "mcpServers" key)
@@ -875,7 +716,7 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
                 },
             };
             yield* writeLockfile(workspaceDir, updatedLockfile).pipe(Effect.provide(fsLayer));
-        })).pipe(Effect.withSpan("Workspace.setMcpServer")),
+        })).pipe(Effect.withSpan("WorkspaceMutations.setMcpServer")),
         setMcpServerLock: ({ name, lockEntry }) => withMutex(Effect.gen(function* () {
             // Update lockfile only (skip settings) — used for pack dependencies
             const currentLockfile = yield* readLockfileSafe(workspaceDir);
@@ -918,7 +759,7 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
                 };
                 yield* writeLockfile(workspaceDir, updatedLockfile).pipe(Effect.provide(fsLayer));
             }
-        })).pipe(Effect.withSpan("Workspace.removeMcpServer")),
+        })).pipe(Effect.withSpan("WorkspaceMutations.removeMcpServer")),
         // -----------------------------------------------------------------------
         // Granular removal methods (settings-only or lockfile-only)
         // -----------------------------------------------------------------------
@@ -930,7 +771,7 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
             void _;
             const updatedLockfile = { ...currentLockfile, skills: remainingSkills };
             yield* writeLockfile(workspaceDir, updatedLockfile).pipe(Effect.provide(fsLayer));
-        })).pipe(Effect.withSpan("Workspace.removeSkillLock")),
+        })).pipe(Effect.withSpan("WorkspaceMutations.removeSkillLock")),
         removeCommandSettings: (name) => withMutex(Effect.gen(function* () {
             const currentSettings = yield* readSettingsSafe(workspaceDir);
             const currentCommands = currentSettings.commands ?? {};
@@ -1070,14 +911,14 @@ export const loadWorkspace = (options) => Effect.gen(function* () {
     };
 });
 /**
- * Create a layer that loads workspace context from disk.
+ * Create a layer that loads workspace read model from disk.
  *
  * The workspace must already be initialized.
  *
- * @param options - Workspace layer options
- * @returns Layer providing WorkspaceContext
+ * @param options - WorkspaceMutations layer options
+ * @returns Layer providing WorkspaceMutations
  *
  * @experimental This API is unstable and may change without notice.
  */
-export const layer = (options) => Layer.effect(Workspace, loadWorkspace(options));
+export const layer = (options) => Layer.effect(WorkspaceMutations, loadWorkspace(options));
 //# sourceMappingURL=service.js.map