@agentxm/workspace-state 0.28.4-bootstrap.0

package/dist/src/workspace/read-model/extensions/knowledge.js

@@ -0,0 +1,121 @@
+/**
+ * Knowledge subject module: declared/resolved/actual payloads, scanner
+ * composition, and projections via the shared helper.
+ *
+ * Declared bundles come from `settings.knowledge`; resolved bundles come from
+ * `axm-lock.yaml` `knowledge`. Actual occurrences come exclusively from the
+ * canonical-extensions scanner (`type === "knowledge"`), which enumerates
+ * project-authored `knowledge/<name>/src`, project-acquired
+ * `agent_extensions/<source>/<source-full-name>`, and user-scope packages.
+ *
+ * Knowledge installs also write two derived artifacts — the `.axm/knowledge/index.md`
+ * catalog and the discovery region inside the agent instructions file. Both live
+ * outside canonical package roots, so the canonical scanner never sees them and they
+ * cannot become occurrences; `actual` is therefore scoped to the materialized
+ * bundle package directory by construction.
+ *
+ * Pack-resolved Knowledge members participate in the same direct-over-pack
+ * projection as every other extension type.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { decodeExtensionNameSync, } from "@agentxm/extension-model/unstable/extensions/common";
+import { filterMapOccurrences } from "./actual-helpers.js";
+import { canonicalAxmPackageRoot } from "./package-root.js";
+import { makeProjectedSubjectCells, projectInstalledExtensions, } from "./projection.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const canonicalToActual = (occ, scope) => {
+    const isExternal = occ.origin === "external-axm";
+    const packageRoot = canonicalAxmPackageRoot(occ);
+    return {
+        key: { scope, type: "knowledge", name: occ.name },
+        origin: isExternal ? { _tag: "external-axm-knowledge" } : { _tag: "canonical-axm-knowledge" },
+        contentRoot: occ.contentLocation,
+        packageRoot,
+    };
+};
+const declaredFromSettings = (settings) => {
+    if (settings.knowledge === undefined)
+        return [];
+    return Object.entries(settings.knowledge).map(([name, entry]) => ({
+        name: decodeExtensionNameSync(name),
+        entry,
+    }));
+};
+const resolvedFromLockfile = (lockfile) => {
+    if (lockfile.knowledge === undefined)
+        return [];
+    return Object.entries(lockfile.knowledge).map(([name, lockEntry]) => ({
+        name: decodeExtensionNameSync(name),
+        lockEntry,
+    }));
+};
+const orphanResolvedWarning = (name) => ({
+    source: "lockfile",
+    message: `knowledge: lockfile entry "${name}" has no matching declared or pack-member home`,
+    code: "orphan-resolved",
+});
+const knowledgePolicy = (scope) => ({
+    declaredEntries: (d) => d,
+    declaredName: (entry) => entry.name,
+    declaredActivation: (entry) => (entry.entry.enabled === false ? "disabled" : "enabled"),
+    resolvedEntries: (r) => r,
+    resolvedName: (entry) => entry.name,
+    actualEntries: (a) => a,
+    actualName: (e) => e.key.name,
+    packMemberName: (member) => member.name,
+    packMemberActivation: () => "enabled",
+    attachActualToInstalled: (name, actual) => actual.filter((a) => a.key.name === name),
+    notClaimedBySubjectPolicy: () => true,
+    buildInstalledRow: (input) => ({
+        key: { scope, type: "knowledge", name: input.name },
+        installationOrigin: input.installationOrigin,
+        activation: input.activation,
+        resolved: input.resolved,
+        actual: input.actual,
+        providingPacks: input.providingPacks,
+    }),
+    buildUnmanagedRow: (entry) => ({
+        key: { scope, type: "knowledge", name: entry.key.name },
+        actual: entry,
+    }),
+    resolvedOrphanWarning: orphanResolvedWarning,
+});
+/**
+ * Build the knowledge subject API. Returns an `Effect` because the projection
+ * cell is wrapped in `Effect.cached` so the four derived cells share one
+ * in-flight execution per scope, mirroring `state.ts`.
+ */
+export const makeKnowledgeExtensionsApi = (deps) => Effect.gen(function* () {
+    const { scope, scanners, diagnostics } = deps;
+    const declared = deps.loaders.settings.pipe(Effect.map((opt) => Option.map(opt, declaredFromSettings)));
+    const resolved = deps.loaders.lockfile.pipe(Effect.map((opt) => Option.map(opt, resolvedFromLockfile)));
+    const actual = Effect.gen(function* () {
+        const canonical = yield* scanners.canonical;
+        return filterMapOccurrences(canonical, "knowledge", (occ) => canonicalToActual(occ, scope));
+    });
+    const project = yield* Effect.cached(projectInstalledExtensions({
+        declared,
+        resolved,
+        actual,
+        installedPacks: deps.installedPacks,
+        packMembers: (pack) => pack.knowledge,
+        packRef: (pack) => pack.ref,
+        policy: knowledgePolicy(scope),
+        diagnostics,
+    }));
+    return {
+        ...makeProjectedSubjectCells({
+            declared,
+            resolved,
+            actual,
+            project,
+        }),
+        declared,
+        resolved,
+        actual,
+    };
+});
+//# sourceMappingURL=knowledge.js.map

package/dist/src/workspace/read-model/extensions/mcp-server.d.ts

@@ -0,0 +1,106 @@
+/**
+ * MCP server subject module: declared/resolved/actual payloads, scanner
+ * composition (canonical-extensions + mcp-config(workspace) + mcp-config(agent)),
+ * and projections via the shared helper.
+ *
+ * MCP servers carry a declared `enabled` flag in settings. Disabled servers
+ * remain installed on disk and in the lockfile but are removed from agent
+ * configs unless the target agent has a native enabled toggle.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import type { AgentId } from "@agentxm/extension-model/unstable/agents/types";
+import { type ExtensionName } from "@agentxm/extension-model/unstable/extensions/common";
+import type { Lockfile, McpServerLockEntry } from "../../../lockfile/schema.js";
+import type { McpServerEntry, Settings } from "../../../settings/schema.js";
+import type { Diagnostics } from "../diagnostics.js";
+import type { LockfileReadError, SettingsReadError } from "../errors.js";
+import type { CanonicalExtensionOccurrence, McpConfigOccurrence } from "../scanners/types.js";
+import type { ActivationState, ExtensionKey, InstallationOrigin, InstalledPackRef, Scope } from "../types.js";
+export type McpServerDetectionOrigin = {
+    readonly _tag: "canonical-axm-mcp-server";
+} | {
+    readonly _tag: "external-axm-mcp-server";
+} | {
+    readonly _tag: "workspace-mcp-config";
+} | {
+    readonly _tag: "agent-mcp-config";
+    readonly agentId: AgentId;
+};
+export interface DeclaredMcpServer {
+    readonly name: ExtensionName;
+    readonly entry: McpServerEntry;
+}
+export type DeclaredMcpServers = ReadonlyArray<DeclaredMcpServer>;
+export interface ResolvedMcpServer {
+    readonly name: ExtensionName;
+    readonly lockEntry: McpServerLockEntry;
+}
+export type ResolvedMcpServers = ReadonlyArray<ResolvedMcpServer>;
+/**
+ * One observable MCP server materialization. `configFile` is the absolute
+ * path to the config file containing the server entry (workspace `.mcp.json`
+ * or an agent-native MCP config). For canonical/external AXM occurrences,
+ * `configFile` is null and `contentRoot` carries the package directory.
+ */
+export interface ActualMcpServer {
+    readonly key: ExtensionKey<"mcp-server">;
+    readonly origin: McpServerDetectionOrigin;
+    readonly contentRoot: string | null;
+    readonly packageRoot: string | null;
+    readonly configFile: string | null;
+    readonly config: Readonly<Record<string, unknown>> | null;
+}
+export type ActualMcpServers = ReadonlyArray<ActualMcpServer>;
+export interface McpServerPackMember {
+    readonly name: ExtensionName;
+    readonly providingPack: InstalledPackRef;
+}
+export interface InstalledMcpServer {
+    readonly key: ExtensionKey<"mcp-server">;
+    readonly installationOrigin: InstallationOrigin<DeclaredMcpServer, McpServerPackMember>;
+    readonly activation: ActivationState;
+    readonly resolved: Option.Option<ResolvedMcpServer>;
+    readonly actual: ReadonlyArray<ActualMcpServer>;
+    readonly providingPacks: ReadonlyArray<InstalledPackRef>;
+}
+export interface UnmanagedMcpServer {
+    readonly key: ExtensionKey<"mcp-server">;
+    readonly actual: ActualMcpServer;
+}
+export interface McpServerScopedLoaders {
+    readonly settings: Effect.Effect<Option.Option<Settings>, SettingsReadError>;
+    readonly lockfile: Effect.Effect<Option.Option<Lockfile>, LockfileReadError>;
+}
+export interface McpServerScanners {
+    readonly canonical: Effect.Effect<ReadonlyArray<CanonicalExtensionOccurrence>>;
+    readonly mcpConfig: Effect.Effect<ReadonlyArray<McpConfigOccurrence>>;
+}
+export interface InstalledPackForMcpServers {
+    readonly ref: InstalledPackRef;
+    readonly mcpServers: ReadonlyArray<McpServerPackMember>;
+}
+export interface McpServerExtensionsApiDeps {
+    readonly scope: Scope;
+    readonly loaders: McpServerScopedLoaders;
+    readonly scanners: McpServerScanners;
+    readonly installedPacks: Effect.Effect<ReadonlyArray<InstalledPackForMcpServers>, SettingsReadError | LockfileReadError>;
+    readonly diagnostics: Diagnostics;
+}
+export interface McpServerExtensionsApi {
+    readonly declared: Effect.Effect<Option.Option<DeclaredMcpServers>, SettingsReadError>;
+    readonly resolved: Effect.Effect<Option.Option<ResolvedMcpServers>, LockfileReadError>;
+    readonly actual: Effect.Effect<ActualMcpServers>;
+    readonly installed: Effect.Effect<ReadonlyArray<InstalledMcpServer>, SettingsReadError | LockfileReadError>;
+    readonly byName: (name: string) => Effect.Effect<Option.Option<InstalledMcpServer>, SettingsReadError | LockfileReadError>;
+    readonly declaredByName: (name: string) => Effect.Effect<Option.Option<DeclaredMcpServer>, SettingsReadError>;
+    readonly active: Effect.Effect<ReadonlyArray<InstalledMcpServer>, SettingsReadError | LockfileReadError>;
+    readonly unmanaged: Effect.Effect<ReadonlyArray<UnmanagedMcpServer>, SettingsReadError | LockfileReadError>;
+}
+/**
+ * Build the MCP server subject API. Returns an `Effect` because the
+ * projection cell is wrapped in `Effect.cached` so the four derived cells
+ * share one in-flight execution per scope, mirroring `state.ts`.
+ */
+export declare const makeMcpServerExtensionsApi: (deps: McpServerExtensionsApiDeps) => Effect.Effect<McpServerExtensionsApi>;
+//# sourceMappingURL=mcp-server.d.ts.map

package/dist/src/workspace/read-model/extensions/mcp-server.js

@@ -0,0 +1,122 @@
+/**
+ * MCP server subject module: declared/resolved/actual payloads, scanner
+ * composition (canonical-extensions + mcp-config(workspace) + mcp-config(agent)),
+ * and projections via the shared helper.
+ *
+ * MCP servers carry a declared `enabled` flag in settings. Disabled servers
+ * remain installed on disk and in the lockfile but are removed from agent
+ * configs unless the target agent has a native enabled toggle.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { decodeExtensionNameSync, } from "@agentxm/extension-model/unstable/extensions/common";
+import { filterMapOccurrences } from "./actual-helpers.js";
+import { canonicalAxmPackageRoot } from "./package-root.js";
+import { makeProjectedSubjectCells, projectInstalledExtensions, } from "./projection.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const declaredFromSettings = (settings) => {
+    if (settings.mcpServers === undefined)
+        return [];
+    return Object.entries(settings.mcpServers).map(([name, entry]) => ({
+        name: decodeExtensionNameSync(name),
+        entry,
+    }));
+};
+const resolvedFromLockfile = (lockfile) => {
+    if (lockfile.mcpServers === undefined)
+        return [];
+    return Object.entries(lockfile.mcpServers).map(([name, lockEntry]) => ({
+        name: decodeExtensionNameSync(name),
+        lockEntry,
+    }));
+};
+const canonicalToActual = (occ, scope) => {
+    const packageRoot = canonicalAxmPackageRoot(occ);
+    return {
+        key: { scope, type: "mcp-server", name: occ.name },
+        origin: occ.origin === "canonical-axm"
+            ? { _tag: "canonical-axm-mcp-server" }
+            : { _tag: "external-axm-mcp-server" },
+        contentRoot: occ.contentLocation,
+        packageRoot,
+        configFile: null,
+        config: null,
+    };
+};
+const mcpConfigToActual = (occ, scope) => ({
+    key: { scope, type: "mcp-server", name: occ.name },
+    origin: occ.surface._tag === "shared"
+        ? { _tag: "workspace-mcp-config" }
+        : { _tag: "agent-mcp-config", agentId: occ.surface.agentId },
+    contentRoot: null,
+    packageRoot: null,
+    configFile: occ.contentLocation,
+    config: occ.config,
+});
+const orphanResolvedWarning = (name) => ({
+    source: "lockfile",
+    message: `mcp-server: lockfile entry "${name}" has no matching declared or pack-member home`,
+    code: "orphan-resolved",
+});
+const mcpServerPolicy = (scope) => ({
+    declaredEntries: (d) => d,
+    declaredName: (e) => e.name,
+    declaredActivation: (entry) => (entry.entry.enabled ? "enabled" : "disabled"),
+    resolvedEntries: (r) => r,
+    resolvedName: (e) => e.name,
+    actualEntries: (a) => a,
+    actualName: (e) => e.key.name,
+    packMemberName: (m) => m.name,
+    packMemberActivation: () => "enabled",
+    attachActualToInstalled: (name, actual) => actual.filter((a) => a.key.name === name),
+    notClaimedBySubjectPolicy: () => true,
+    buildInstalledRow: (input) => ({
+        key: { scope, type: "mcp-server", name: input.name },
+        installationOrigin: input.installationOrigin,
+        activation: input.activation,
+        resolved: input.resolved,
+        actual: input.actual,
+        providingPacks: input.providingPacks,
+    }),
+    buildUnmanagedRow: (entry) => ({
+        key: { scope, type: "mcp-server", name: entry.key.name },
+        actual: entry,
+    }),
+    resolvedOrphanWarning: orphanResolvedWarning,
+});
+/**
+ * Build the MCP server subject API. Returns an `Effect` because the
+ * projection cell is wrapped in `Effect.cached` so the four derived cells
+ * share one in-flight execution per scope, mirroring `state.ts`.
+ */
+export const makeMcpServerExtensionsApi = (deps) => Effect.gen(function* () {
+    const { scope, loaders, scanners, installedPacks, diagnostics } = deps;
+    const declared = loaders.settings.pipe(Effect.map((opt) => Option.map(opt, declaredFromSettings)));
+    const resolved = loaders.lockfile.pipe(Effect.map((opt) => Option.map(opt, resolvedFromLockfile)));
+    const actual = Effect.gen(function* () {
+        const canonical = yield* scanners.canonical;
+        const mcpConfig = yield* scanners.mcpConfig;
+        const fromCanonical = filterMapOccurrences(canonical, "mcp-server", (occ) => canonicalToActual(occ, scope));
+        const fromMcpConfig = mcpConfig.map((occ) => mcpConfigToActual(occ, scope));
+        return [...fromCanonical, ...fromMcpConfig];
+    });
+    const project = yield* Effect.cached(projectInstalledExtensions({
+        declared,
+        resolved,
+        actual,
+        installedPacks: installedPacks.pipe(Effect.map((packs) => packs.map((p) => ({ ref: p.ref, members: p.mcpServers })))),
+        packMembers: (pack) => pack.members,
+        packRef: (pack) => pack.ref,
+        policy: mcpServerPolicy(scope),
+        diagnostics,
+    }));
+    return makeProjectedSubjectCells({
+        declared,
+        resolved,
+        actual,
+        project,
+    });
+});
+//# sourceMappingURL=mcp-server.js.map

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

@@ -0,0 +1,104 @@
+/**
+ * Pack subject module: declared/resolved/actual payloads, scanner composition,
+ * and **direct-only** installed projections via the shared helper.
+ *
+ * Per Decision 9 of the workspace read-model design: packs cannot be members of
+ * other packs. The pack subject's own `installed` projection therefore passes
+ * an empty installed-pack set into the projection helper, so no pack-member
+ * row is ever produced for a pack. Direct pack declarations remain the only
+ * way a pack appears in `installed`.
+ *
+ * Other subjects derive Pack membership from the authored `pack.json`
+ * manifest. The lock entry carries only accepted external resolution.
+ *
+ * Pack activation follows its declared settings entry. Disabled packs retain
+ * their declaration, lock data, and canonical content while leaving the
+ * active projection.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { type ExtensionName } from "@agentxm/extension-model/unstable/extensions/common";
+import type { PackLockEntry, Lockfile } from "../../../lockfile/schema.js";
+import type { PackEntry, Settings } from "../../../settings/schema.js";
+import type { Diagnostics } from "../diagnostics.js";
+import type { LockfileReadError, SettingsReadError } from "../errors.js";
+import type { CanonicalExtensionOccurrence } from "../scanners/types.js";
+import type { ActivationState, ExtensionKey, InstallationOrigin, InstalledPackRef, Scope } from "../types.js";
+export type PackDetectionOrigin = {
+    readonly _tag: "canonical-axm-pack";
+} | {
+    readonly _tag: "external-axm-pack";
+};
+export interface DeclaredPack {
+    readonly name: ExtensionName;
+    readonly entry: PackEntry;
+}
+export type DeclaredPacks = ReadonlyArray<DeclaredPack>;
+/** Resolved Pack carrying the accepted external-resolution row verbatim. */
+export interface ResolvedPack {
+    readonly keyName: string;
+    readonly name: ExtensionName;
+    readonly lockEntry: PackLockEntry;
+}
+export type ResolvedPacks = ReadonlyArray<ResolvedPack>;
+export interface ActualPack {
+    readonly key: ExtensionKey<"pack">;
+    readonly origin: PackDetectionOrigin;
+    readonly contentRoot: string;
+    readonly packageRoot: string | null;
+}
+export type ActualPacks = ReadonlyArray<ActualPack>;
+/**
+ * Pack member entry carrying enough info to identify the source pack. Pack
+ * subjects do not produce member rows (packs are not pack members), but the
+ * shared projection helper still type-parameters its pack-member type, so we
+ * supply a never-instantiated placeholder.
+ */
+export type PackPackMember = never;
+/**
+ * Installed pack row. The installation origin union is widened only to
+ * `direct` because packs cannot be pack members. Generic consumers reading
+ * `installationOrigin._tag` always observe `"direct"` on a pack row.
+ */
+export interface InstalledPack {
+    readonly key: ExtensionKey<"pack">;
+    readonly installationOrigin: InstallationOrigin<DeclaredPack, PackPackMember>;
+    readonly activation: ActivationState;
+    readonly resolved: Option.Option<ResolvedPack>;
+    readonly actual: ReadonlyArray<ActualPack>;
+    readonly providingPacks: ReadonlyArray<InstalledPackRef>;
+}
+export interface UnmanagedPack {
+    readonly key: ExtensionKey<"pack">;
+    readonly actual: ActualPack;
+}
+export interface PackScopedLoaders {
+    readonly settings: Effect.Effect<Option.Option<Settings>, SettingsReadError>;
+    readonly lockfile: Effect.Effect<Option.Option<Lockfile>, LockfileReadError>;
+}
+export interface PackScanners {
+    readonly canonical: Effect.Effect<ReadonlyArray<CanonicalExtensionOccurrence>>;
+}
+export interface PackExtensionsApiDeps {
+    readonly scope: Scope;
+    readonly loaders: PackScopedLoaders;
+    readonly scanners: PackScanners;
+    readonly diagnostics: Diagnostics;
+}
+export interface PackExtensionsApi {
+    readonly declared: Effect.Effect<Option.Option<DeclaredPacks>, SettingsReadError>;
+    readonly resolved: Effect.Effect<Option.Option<ResolvedPacks>, LockfileReadError>;
+    readonly actual: Effect.Effect<ActualPacks>;
+    readonly installed: Effect.Effect<ReadonlyArray<InstalledPack>, SettingsReadError | LockfileReadError>;
+    readonly byName: (name: string) => Effect.Effect<Option.Option<InstalledPack>, SettingsReadError | LockfileReadError>;
+    readonly declaredByName: (name: string) => Effect.Effect<Option.Option<DeclaredPack>, SettingsReadError>;
+    readonly active: Effect.Effect<ReadonlyArray<InstalledPack>, SettingsReadError | LockfileReadError>;
+    readonly unmanaged: Effect.Effect<ReadonlyArray<UnmanagedPack>, SettingsReadError | LockfileReadError>;
+}
+/**
+ * Build the pack subject API. Returns an `Effect` because the projection
+ * cell is wrapped in `Effect.cached` so the four derived cells share one
+ * in-flight execution per scope, mirroring `state.ts`.
+ */
+export declare const makePackExtensionsApi: (deps: PackExtensionsApiDeps) => Effect.Effect<PackExtensionsApi>;
+//# sourceMappingURL=pack.d.ts.map

package/dist/src/workspace/read-model/extensions/pack.js

@@ -0,0 +1,123 @@
+/**
+ * Pack subject module: declared/resolved/actual payloads, scanner composition,
+ * and **direct-only** installed projections via the shared helper.
+ *
+ * Per Decision 9 of the workspace read-model design: packs cannot be members of
+ * other packs. The pack subject's own `installed` projection therefore passes
+ * an empty installed-pack set into the projection helper, so no pack-member
+ * row is ever produced for a pack. Direct pack declarations remain the only
+ * way a pack appears in `installed`.
+ *
+ * Other subjects derive Pack membership from the authored `pack.json`
+ * manifest. The lock entry carries only accepted external resolution.
+ *
+ * Pack activation follows its declared settings entry. Disabled packs retain
+ * their declaration, lock data, and canonical content while leaving the
+ * active projection.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { decodeExtensionNameSync, parseExtensionFqnParts, } from "@agentxm/extension-model/unstable/extensions/common";
+import { filterMapOccurrences } from "./actual-helpers.js";
+import { canonicalAxmPackageRoot } from "./package-root.js";
+import { makeProjectedSubjectCells, projectInstalledExtensions, } from "./projection.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const declaredFromSettings = (settings) => {
+    if (settings.packs === undefined)
+        return [];
+    return Object.entries(settings.packs).map(([name, entry]) => ({
+        name: decodeExtensionNameSync(name),
+        entry,
+    }));
+};
+const resolvedFromLockfile = (lockfile) => {
+    if (lockfile.packs === undefined)
+        return [];
+    return Object.entries(lockfile.packs).map(([keyName, lockEntry]) => {
+        const parsed = parseExtensionFqnParts(keyName);
+        return {
+            keyName,
+            name: parsed?.name ?? decodeExtensionNameSync(keyName),
+            lockEntry,
+        };
+    });
+};
+const canonicalToActual = (occ, scope) => {
+    const isExternal = occ.origin === "external-axm";
+    const packageRoot = canonicalAxmPackageRoot(occ);
+    return {
+        key: { scope, type: "pack", name: occ.name },
+        origin: isExternal ? { _tag: "external-axm-pack" } : { _tag: "canonical-axm-pack" },
+        contentRoot: occ.contentLocation,
+        packageRoot,
+    };
+};
+const orphanResolvedWarning = (name) => ({
+    source: "lockfile",
+    message: `pack: lockfile entry "${name}" has no matching declared pack`,
+    code: "orphan-resolved",
+});
+const packPolicy = (scope) => ({
+    declaredEntries: (d) => d,
+    declaredName: (e) => e.name,
+    declaredActivation: (entry) => (entry.entry.enabled ? "enabled" : "disabled"),
+    resolvedEntries: (r) => r,
+    resolvedName: (e) => e.name,
+    actualEntries: (a) => a,
+    actualName: (e) => e.key.name,
+    // Pack-member callbacks are unreachable: the subject passes an empty
+    // installed-pack set into the projection helper, so the helper never
+    // invokes these. The functions still need to satisfy the types.
+    packMemberName: (member) => member,
+    packMemberActivation: () => "enabled",
+    attachActualToInstalled: (name, actual) => actual.filter((a) => a.key.name === name),
+    notClaimedBySubjectPolicy: () => true,
+    buildInstalledRow: (input) => ({
+        key: { scope, type: "pack", name: input.name },
+        installationOrigin: input.installationOrigin,
+        activation: input.activation,
+        resolved: input.resolved,
+        actual: input.actual,
+        providingPacks: input.providingPacks,
+    }),
+    buildUnmanagedRow: (entry) => ({
+        key: { scope, type: "pack", name: entry.key.name },
+        actual: entry,
+    }),
+    resolvedOrphanWarning: orphanResolvedWarning,
+});
+/**
+ * Build the pack subject API. Returns an `Effect` because the projection
+ * cell is wrapped in `Effect.cached` so the four derived cells share one
+ * in-flight execution per scope, mirroring `state.ts`.
+ */
+export const makePackExtensionsApi = (deps) => Effect.gen(function* () {
+    const { scope, loaders, scanners, diagnostics } = deps;
+    const declared = loaders.settings.pipe(Effect.map((opt) => Option.map(opt, declaredFromSettings)));
+    const resolved = loaders.lockfile.pipe(Effect.map((opt) => Option.map(opt, resolvedFromLockfile)));
+    const actual = Effect.gen(function* () {
+        const canonical = yield* scanners.canonical;
+        return filterMapOccurrences(canonical, "pack", (occ) => canonicalToActual(occ, scope));
+    });
+    // Packs can't be pack members — pass an empty installed-pack set.
+    const installedPacks = Effect.succeed([]);
+    const project = yield* Effect.cached(projectInstalledExtensions({
+        declared,
+        resolved,
+        actual,
+        installedPacks,
+        packMembers: (pack) => pack.members,
+        packRef: (pack) => pack.ref,
+        policy: packPolicy(scope),
+        diagnostics,
+    }));
+    return makeProjectedSubjectCells({
+        declared,
+        resolved,
+        actual,
+        project,
+    });
+});
+//# sourceMappingURL=pack.js.map

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

@@ -0,0 +1,39 @@
+/**
+ * Internal helper for computing ancestor paths from scanner-emitted
+ * `pathSegments` + `contentLocation` without re-introducing a `Path` service
+ * dependency in subject modules.
+ *
+ * The canonical-extensions scanner already splits `contentLocation` into
+ * `pathSegments` via the `Path` service. This helper inverts that: it derives
+ * the platform separator from the relationship between the segments and the
+ * original string, then joins a prefix back to a path.
+ *
+ * Why this exists: subject modules need `packageRoot` (the parent or
+ * grandparent directory of `contentLocation`). They never see the `Path`
+ * service — that lives at the live-layer construction boundary. The scanner's
+ * `pathSegments` field carries enough structure to reconstruct any ancestor.
+ *
+ * Cross-platform behavior:
+ *
+ * - POSIX `/ws/agent_extensions/agentxm/@o/skills/x/src` →
+ *   `pathSegments = ["", "ws", "agent_extensions", "agentxm", "@o", "skills", "x", "src"]`.
+ *   Dropping the trailing `src` segment yields the package root
+ *   `/ws/agent_extensions/agentxm/@o/skills/x`.
+ * - Windows `C:\\ws\\agent_extensions\\agentxm\\@o\\skills\\x\\src` →
+ *   `pathSegments = ["C:", "ws", "agent_extensions", "agentxm", "@o", "skills", "x", "src"]`.
+ *   `pathSegments[0]` is `"C:"` (length 2); the separator is
+ *   `contentLocation.charAt(2) = "\\"`. Joining yields
+ *   `C:\\ws\\agent_extensions\\agentxm\\@o\\skills`.
+ */
+/**
+ * Drop the trailing `count` segments from `pathSegments` and rejoin the
+ * remainder with the separator inferred from `contentLocation`. Returns the
+ * empty string if all segments would be dropped.
+ */
+export declare const stripTrailingSegments: (pathSegments: ReadonlyArray<string>, contentLocation: string, count: number) => string;
+export declare const canonicalAxmPackageRoot: (occ: {
+    readonly origin: "canonical-axm" | "external-axm";
+    readonly pathSegments: ReadonlyArray<string>;
+    readonly contentLocation: string;
+}) => string;
+//# sourceMappingURL=package-root.d.ts.map

package/dist/src/workspace/read-model/extensions/package-root.js

@@ -0,0 +1,48 @@
+/**
+ * Internal helper for computing ancestor paths from scanner-emitted
+ * `pathSegments` + `contentLocation` without re-introducing a `Path` service
+ * dependency in subject modules.
+ *
+ * The canonical-extensions scanner already splits `contentLocation` into
+ * `pathSegments` via the `Path` service. This helper inverts that: it derives
+ * the platform separator from the relationship between the segments and the
+ * original string, then joins a prefix back to a path.
+ *
+ * Why this exists: subject modules need `packageRoot` (the parent or
+ * grandparent directory of `contentLocation`). They never see the `Path`
+ * service — that lives at the live-layer construction boundary. The scanner's
+ * `pathSegments` field carries enough structure to reconstruct any ancestor.
+ *
+ * Cross-platform behavior:
+ *
+ * - POSIX `/ws/agent_extensions/agentxm/@o/skills/x/src` →
+ *   `pathSegments = ["", "ws", "agent_extensions", "agentxm", "@o", "skills", "x", "src"]`.
+ *   Dropping the trailing `src` segment yields the package root
+ *   `/ws/agent_extensions/agentxm/@o/skills/x`.
+ * - Windows `C:\\ws\\agent_extensions\\agentxm\\@o\\skills\\x\\src` →
+ *   `pathSegments = ["C:", "ws", "agent_extensions", "agentxm", "@o", "skills", "x", "src"]`.
+ *   `pathSegments[0]` is `"C:"` (length 2); the separator is
+ *   `contentLocation.charAt(2) = "\\"`. Joining yields
+ *   `C:\\ws\\agent_extensions\\agentxm\\@o\\skills`.
+ */
+/**
+ * Drop the trailing `count` segments from `pathSegments` and rejoin the
+ * remainder with the separator inferred from `contentLocation`. Returns the
+ * empty string if all segments would be dropped.
+ */
+export const stripTrailingSegments = (pathSegments, contentLocation, count) => {
+    if (pathSegments.length <= count)
+        return "";
+    const sep = contentLocation.charAt(pathSegments[0]?.length ?? 0);
+    return pathSegments.slice(0, pathSegments.length - count).join(sep);
+};
+export const canonicalAxmPackageRoot = (occ) => {
+    if (occ.origin === "external-axm")
+        return occ.contentLocation;
+    const last = occ.pathSegments.at(-1);
+    if (last === "src") {
+        return stripTrailingSegments(occ.pathSegments, occ.contentLocation, 1);
+    }
+    return occ.contentLocation;
+};
+//# sourceMappingURL=package-root.js.map