@agentxm/workspace-state 0.28.4-bootstrap.0

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

@@ -0,0 +1,170 @@
+/**
+ * Skill subject module: declared/resolved/actual payload types, scanner
+ * composition, and projections via the shared `projectInstalledExtensions`
+ * helper.
+ *
+ * Per Decision 4 (single service + per-subject modules) and Decision 9
+ * (read-model rows) of the workspace read-model design, this module owns:
+ *
+ * - the subject-specific declared/resolved/actual payload types
+ *   (`DeclaredSkills`, `ResolvedSkills`, `ActualSkills`);
+ * - the subject-specific origin union (`SkillDetectionOrigin`) and
+ *   skill-specific facts (`contentRoot`, `sourcePath`, `packageRoot`,
+ *   `hasSkillMd`, `hasSkillJson`);
+ * - scanner composition (canonical-extensions + agent-dir × skill-rendering
+ *   agents);
+ * - the `installed` / `active` / `unmanaged` projections, wired
+ *   through the helper with a skill-specific `SubjectPolicy`.
+ *
+ * The factory `makeSkillExtensionsApi(deps)` returns a `SkillExtensionsApi`
+ * with cells whose public types are dependency-closed. Phase 9 composes the
+ * factory inputs (`loaders`, `scanners`, `installedPacks`, `diagnostics`)
+ * inside `WorkspaceReadModelLive`.
+ */
+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, SkillLockEntry } from "../../../lockfile/schema.js";
+import type { Settings, SkillEntry } from "../../../settings/schema.js";
+import type { Diagnostics } from "../diagnostics.js";
+import type { LockfileReadError, SettingsReadError } from "../errors.js";
+import type { AgentDirOccurrence, CanonicalExtensionOccurrence } from "../scanners/types.js";
+import type { ActivationState, ExtensionKey, InstallationOrigin, InstalledPackRef, Scope } from "../types.js";
+/**
+ * Subject-specific origin discriminator for an `ActualSkill`. Mirrors the spec
+ * scenarios that distinguish canonical AXM, external AXM, and agent-rendered
+ * skill directories.
+ */
+export type SkillDetectionOrigin = {
+    readonly _tag: "canonical-axm-skill";
+} | {
+    readonly _tag: "external-axm-skill";
+} | {
+    readonly _tag: "agent-skill-dir";
+    readonly agentId: AgentId;
+};
+/**
+ * One declared skill entry. Wraps the raw settings entry without re-shaping
+ * fields; `name` is lifted out for ergonomic lookup.
+ */
+export interface DeclaredSkill {
+    readonly name: ExtensionName;
+    readonly entry: SkillEntry;
+}
+/** Decoded skills declared in `axm.json`. */
+export type DeclaredSkills = ReadonlyArray<DeclaredSkill>;
+/** One resolved skill entry from the lockfile, wrapping the raw lock entry. */
+export interface ResolvedSkill {
+    readonly name: ExtensionName;
+    readonly lockEntry: SkillLockEntry;
+}
+/** Decoded skills resolved in the lockfile. */
+export type ResolvedSkills = ReadonlyArray<ResolvedSkill>;
+/**
+ * One observable skill materialization. Carries the subject-specific origin
+ * plus skill-specific facts:
+ *
+ * - `contentRoot` — the directory containing the rendered skill (the same
+ *   value as the underlying scanner's `contentLocation`);
+ * - `sourcePath` — absolute path to the canonical content file inside
+ *   `contentRoot` (`SKILL.md`); equal to `null` if the file does not exist;
+ * - `packageRoot` — for canonical/external AXM, the registry-publish package
+ *   root (parent of `src/<name>/`); `null` for agent-rendered skills;
+ * - `hasSkillMd` — convenience boolean derived from `sourcePath`;
+ * - `hasSkillJson` — placeholder for the optional `skill.json` companion file
+ *   (left `false` in v1; Phase 9 wiring will flip when `agent-settings` or a
+ *   future scanner detects it).
+ */
+export interface ActualSkill {
+    readonly key: ExtensionKey<"skill">;
+    readonly origin: SkillDetectionOrigin;
+    readonly contentRoot: string;
+    readonly sourcePath: string | null;
+    readonly packageRoot: string | null;
+    readonly hasSkillMd: boolean;
+    readonly hasSkillJson: boolean;
+}
+/** Actual skills payload — array of observed materialization occurrences. */
+export type ActualSkills = ReadonlyArray<ActualSkill>;
+/** Pack-member entry for a skill: per Decision 9 it is the resolved member. */
+export interface SkillPackMember {
+    readonly name: ExtensionName;
+    readonly providingPack: InstalledPackRef;
+}
+/** Installed skill row. */
+export interface InstalledSkill {
+    readonly key: ExtensionKey<"skill">;
+    readonly installationOrigin: InstallationOrigin<DeclaredSkill, SkillPackMember>;
+    readonly activation: ActivationState;
+    readonly resolved: Option.Option<ResolvedSkill>;
+    readonly actual: ReadonlyArray<ActualSkill>;
+    readonly providingPacks: ReadonlyArray<InstalledPackRef>;
+}
+/** Unmanaged skill row — one actual occurrence not attached to an installed row. */
+export interface UnmanagedSkill {
+    readonly key: ExtensionKey<"skill">;
+    readonly actual: ActualSkill;
+}
+/**
+ * Cached source loaders the factory captures. `Effect.cached` is applied at
+ * the loader site (Phase 4); the helper just consumes whatever shape the
+ * caller passes in.
+ */
+export interface SkillScopedLoaders {
+    readonly settings: Effect.Effect<Option.Option<Settings>, SettingsReadError>;
+    readonly lockfile: Effect.Effect<Option.Option<Lockfile>, LockfileReadError>;
+}
+/**
+ * Cached scanner outputs the factory captures. The factory composes
+ * canonical-extensions + agent-dir occurrences into the actual skill array.
+ */
+export interface SkillScanners {
+    readonly canonical: Effect.Effect<ReadonlyArray<CanonicalExtensionOccurrence>>;
+    readonly agentDir: Effect.Effect<ReadonlyArray<AgentDirOccurrence>>;
+}
+/**
+ * One installed-pack entry consumed by the projection. Pack-resolved member
+ * groups are read from the **installed pack manifest** in Phase 9; for unit
+ * tests the caller passes a synthetic shape.
+ */
+export interface InstalledPackForSkills {
+    readonly ref: InstalledPackRef;
+    readonly skills: ReadonlyArray<SkillPackMember>;
+}
+/**
+ * Inputs `makeSkillExtensionsApi` captures.
+ */
+export interface SkillExtensionsApiDeps {
+    readonly scope: Scope;
+    readonly loaders: SkillScopedLoaders;
+    readonly scanners: SkillScanners;
+    readonly installedPacks: Effect.Effect<ReadonlyArray<InstalledPackForSkills>, SettingsReadError | LockfileReadError>;
+    readonly diagnostics: Diagnostics;
+}
+/**
+ * Public skill API exposed by `ctx.scope(scope).skills`. Cells are
+ * dependency-closed and never carry `FileSystem | Path` requirements.
+ */
+export interface SkillExtensionsApi {
+    readonly declared: Effect.Effect<Option.Option<DeclaredSkills>, SettingsReadError>;
+    readonly resolved: Effect.Effect<Option.Option<ResolvedSkills>, LockfileReadError>;
+    readonly actual: Effect.Effect<ActualSkills>;
+    readonly installed: Effect.Effect<ReadonlyArray<InstalledSkill>, SettingsReadError | LockfileReadError>;
+    readonly byName: (name: string) => Effect.Effect<Option.Option<InstalledSkill>, SettingsReadError | LockfileReadError>;
+    readonly declaredByName: (name: string) => Effect.Effect<Option.Option<DeclaredSkill>, SettingsReadError>;
+    readonly active: Effect.Effect<ReadonlyArray<InstalledSkill>, SettingsReadError | LockfileReadError>;
+    readonly unmanaged: Effect.Effect<ReadonlyArray<UnmanagedSkill>, SettingsReadError | LockfileReadError>;
+}
+/**
+ * Build the skill subject API over the captured loaders, scanners, and pack
+ * set.
+ *
+ * Returns an `Effect` because the projection cell is wrapped in
+ * `Effect.cached` so all four derived cells (`installed` / `active` /
+ * `unmanaged`) share a single in-flight execution and the
+ * projection — including its diagnostic side effects — runs at most once per
+ * scope, mirroring the `state.ts` loader pattern.
+ */
+export declare const makeSkillExtensionsApi: (deps: SkillExtensionsApiDeps) => Effect.Effect<SkillExtensionsApi>;
+//# sourceMappingURL=skill.d.ts.map

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

@@ -0,0 +1,148 @@
+/**
+ * Skill subject module: declared/resolved/actual payload types, scanner
+ * composition, and projections via the shared `projectInstalledExtensions`
+ * helper.
+ *
+ * Per Decision 4 (single service + per-subject modules) and Decision 9
+ * (read-model rows) of the workspace read-model design, this module owns:
+ *
+ * - the subject-specific declared/resolved/actual payload types
+ *   (`DeclaredSkills`, `ResolvedSkills`, `ActualSkills`);
+ * - the subject-specific origin union (`SkillDetectionOrigin`) and
+ *   skill-specific facts (`contentRoot`, `sourcePath`, `packageRoot`,
+ *   `hasSkillMd`, `hasSkillJson`);
+ * - scanner composition (canonical-extensions + agent-dir × skill-rendering
+ *   agents);
+ * - the `installed` / `active` / `unmanaged` projections, wired
+ *   through the helper with a skill-specific `SubjectPolicy`.
+ *
+ * The factory `makeSkillExtensionsApi(deps)` returns a `SkillExtensionsApi`
+ * with cells whose public types are dependency-closed. Phase 9 composes the
+ * factory inputs (`loaders`, `scanners`, `installedPacks`, `diagnostics`)
+ * inside `WorkspaceReadModelLive`.
+ */
+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 — declared / resolved / actual normalization
+// ---------------------------------------------------------------------------
+const declaredFromSettings = (settings) => {
+    if (settings.skills === undefined)
+        return [];
+    return Object.entries(settings.skills).map(([name, entry]) => ({
+        name: decodeExtensionNameSync(name),
+        entry,
+    }));
+};
+const resolvedFromLockfile = (lockfile) => {
+    if (lockfile.skills === undefined)
+        return [];
+    return Object.entries(lockfile.skills).map(([name, lockEntry]) => ({
+        name: decodeExtensionNameSync(name),
+        lockEntry,
+    }));
+};
+const canonicalToActualSkill = (occ, scope) => {
+    const isExternal = occ.origin === "external-axm";
+    // canonical-axm contentLocation ends in `<package>/src` for authored and
+    // owner-qualified packages; external-axm contentLocation is the legacy
+    // user-scope external package root.
+    const packageRoot = canonicalAxmPackageRoot(occ);
+    return {
+        key: { scope, type: "skill", name: occ.name },
+        origin: isExternal ? { _tag: "external-axm-skill" } : { _tag: "canonical-axm-skill" },
+        contentRoot: occ.contentLocation,
+        sourcePath: Option.getOrNull(occ.subjectFile),
+        packageRoot,
+        hasSkillMd: occ.subjectFileExists,
+        // Scanner does not probe `skill.json` yet; keep `false` until a future
+        // scanner emission carries it.
+        hasSkillJson: false,
+    };
+};
+const agentDirToActualSkill = (occ, scope) => ({
+    key: { scope, type: "skill", name: occ.name },
+    origin: { _tag: "agent-skill-dir", agentId: occ.agentId },
+    contentRoot: occ.contentLocation,
+    sourcePath: Option.getOrNull(occ.subjectFile),
+    packageRoot: null,
+    hasSkillMd: occ.subjectFileExists,
+    // Scanner does not probe `skill.json` yet; keep `false` until a future
+    // scanner emission carries it.
+    hasSkillJson: false,
+});
+const simpleName = (name) => name;
+const orphanResolvedWarning = (name) => ({
+    source: "lockfile",
+    message: `skill: lockfile entry "${name}" has no matching declared or pack-member home`,
+    code: "orphan-resolved",
+});
+const skillPolicy = (scope) => ({
+    declaredEntries: (declared) => declared,
+    declaredName: (entry) => entry.name,
+    declaredActivation: (entry) => (entry.entry.enabled ? "enabled" : "disabled"),
+    resolvedEntries: (resolved) => resolved,
+    resolvedName: (entry) => simpleName(entry.name),
+    actualEntries: (actual) => actual,
+    actualName: (entry) => entry.key.name,
+    packMemberName: (member) => simpleName(member.name),
+    packMemberActivation: () => "enabled",
+    attachActualToInstalled: (name, actual) => actual.filter((a) => a.key.name === name),
+    notClaimedBySubjectPolicy: () => true,
+    buildInstalledRow: (input) => ({
+        key: { scope, type: "skill", name: input.name },
+        installationOrigin: input.installationOrigin,
+        activation: input.activation,
+        resolved: input.resolved,
+        actual: input.actual,
+        providingPacks: input.providingPacks,
+    }),
+    buildUnmanagedRow: (entry) => ({
+        key: { scope, type: "skill", name: entry.key.name },
+        actual: entry,
+    }),
+    resolvedOrphanWarning: orphanResolvedWarning,
+});
+/**
+ * Build the skill subject API over the captured loaders, scanners, and pack
+ * set.
+ *
+ * Returns an `Effect` because the projection cell is wrapped in
+ * `Effect.cached` so all four derived cells (`installed` / `active` /
+ * `unmanaged`) share a single in-flight execution and the
+ * projection — including its diagnostic side effects — runs at most once per
+ * scope, mirroring the `state.ts` loader pattern.
+ */
+export const makeSkillExtensionsApi = (deps) => Effect.gen(function* () {
+    const { scope, loaders, scanners, installedPacks, diagnostics } = deps;
+    const declared = loaders.settings.pipe(Effect.map((opt) => Option.map(opt, (settings) => declaredFromSettings(settings))));
+    const resolved = loaders.lockfile.pipe(Effect.map((opt) => Option.map(opt, (lockfile) => resolvedFromLockfile(lockfile))));
+    const actual = Effect.gen(function* () {
+        const canonical = yield* scanners.canonical;
+        const agentDir = yield* scanners.agentDir;
+        const fromCanonical = filterMapOccurrences(canonical, "skill", (occ) => canonicalToActualSkill(occ, scope));
+        const fromAgentDir = filterMapOccurrences(agentDir, "skill", (occ) => agentDirToActualSkill(occ, scope));
+        return [...fromCanonical, ...fromAgentDir];
+    });
+    const project = yield* Effect.cached(projectInstalledExtensions({
+        declared,
+        resolved,
+        actual,
+        installedPacks: installedPacks.pipe(Effect.map((packs) => packs.map((p) => ({ ref: p.ref, members: p.skills })))),
+        packMembers: (pack) => pack.members,
+        packRef: (pack) => pack.ref,
+        policy: skillPolicy(scope),
+        diagnostics,
+    }));
+    return makeProjectedSubjectCells({
+        declared,
+        resolved,
+        actual,
+        project,
+    });
+});
+//# sourceMappingURL=skill.js.map

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

@@ -0,0 +1,97 @@
+/**
+ * Subagent subject module: declared/resolved/actual payloads, scanner
+ * composition (canonical-extensions + agent-dir × subagent-rendering agents),
+ * and projections via the shared helper.
+ *
+ * Activation comes from the declared `enabled` flag, mirroring skills and
+ * commands. Single-file subagent surfaces (e.g., `roo`'s `.roomodes`) emit
+ * one occurrence per file path; the file itself is the materialization.
+ */
+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, SubagentLockEntry } from "../../../lockfile/schema.js";
+import type { Settings, SubagentEntry } from "../../../settings/schema.js";
+import type { Diagnostics } from "../diagnostics.js";
+import type { LockfileReadError, SettingsReadError } from "../errors.js";
+import type { AgentDirOccurrence, CanonicalExtensionOccurrence } from "../scanners/types.js";
+import type { ActivationState, ExtensionKey, InstallationOrigin, InstalledPackRef, Scope } from "../types.js";
+export type SubagentDetectionOrigin = {
+    readonly _tag: "canonical-axm-subagent";
+} | {
+    readonly _tag: "external-axm-subagent";
+} | {
+    readonly _tag: "agent-subagent-dir";
+    readonly agentId: AgentId;
+};
+export interface DeclaredSubagent {
+    readonly name: ExtensionName;
+    readonly entry: SubagentEntry;
+}
+export type DeclaredSubagents = ReadonlyArray<DeclaredSubagent>;
+export interface ResolvedSubagent {
+    readonly name: ExtensionName;
+    readonly lockEntry: SubagentLockEntry;
+}
+export type ResolvedSubagents = ReadonlyArray<ResolvedSubagent>;
+export interface ActualSubagent {
+    readonly key: ExtensionKey<"subagent">;
+    readonly origin: SubagentDetectionOrigin;
+    readonly contentRoot: string;
+    readonly sourcePath: string | null;
+    readonly packageRoot: string | null;
+}
+export type ActualSubagents = ReadonlyArray<ActualSubagent>;
+export interface SubagentPackMember {
+    readonly name: ExtensionName;
+    readonly providingPack: InstalledPackRef;
+}
+export interface InstalledSubagent {
+    readonly key: ExtensionKey<"subagent">;
+    readonly installationOrigin: InstallationOrigin<DeclaredSubagent, SubagentPackMember>;
+    readonly activation: ActivationState;
+    readonly resolved: Option.Option<ResolvedSubagent>;
+    readonly actual: ReadonlyArray<ActualSubagent>;
+    readonly providingPacks: ReadonlyArray<InstalledPackRef>;
+}
+export interface UnmanagedSubagent {
+    readonly key: ExtensionKey<"subagent">;
+    readonly actual: ActualSubagent;
+}
+export interface SubagentScopedLoaders {
+    readonly settings: Effect.Effect<Option.Option<Settings>, SettingsReadError>;
+    readonly lockfile: Effect.Effect<Option.Option<Lockfile>, LockfileReadError>;
+}
+export interface SubagentScanners {
+    readonly canonical: Effect.Effect<ReadonlyArray<CanonicalExtensionOccurrence>>;
+    readonly agentDir: Effect.Effect<ReadonlyArray<AgentDirOccurrence>>;
+}
+export interface InstalledPackForSubagents {
+    readonly ref: InstalledPackRef;
+    readonly subagents: ReadonlyArray<SubagentPackMember>;
+}
+export interface SubagentExtensionsApiDeps {
+    readonly scope: Scope;
+    readonly loaders: SubagentScopedLoaders;
+    readonly scanners: SubagentScanners;
+    readonly installedPacks: Effect.Effect<ReadonlyArray<InstalledPackForSubagents>, SettingsReadError | LockfileReadError>;
+    readonly diagnostics: Diagnostics;
+}
+export interface SubagentExtensionsApi {
+    readonly declared: Effect.Effect<Option.Option<DeclaredSubagents>, SettingsReadError>;
+    readonly resolved: Effect.Effect<Option.Option<ResolvedSubagents>, LockfileReadError>;
+    readonly actual: Effect.Effect<ActualSubagents>;
+    readonly installed: Effect.Effect<ReadonlyArray<InstalledSubagent>, SettingsReadError | LockfileReadError>;
+    readonly byName: (name: string) => Effect.Effect<Option.Option<InstalledSubagent>, SettingsReadError | LockfileReadError>;
+    readonly declaredByName: (name: string) => Effect.Effect<Option.Option<DeclaredSubagent>, SettingsReadError>;
+    readonly active: Effect.Effect<ReadonlyArray<InstalledSubagent>, SettingsReadError | LockfileReadError>;
+    readonly unmanaged: Effect.Effect<ReadonlyArray<UnmanagedSubagent>, SettingsReadError | LockfileReadError>;
+}
+/**
+ * Build the subagent 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 makeSubagentExtensionsApi: (deps: SubagentExtensionsApiDeps) => Effect.Effect<SubagentExtensionsApi>;
+//# sourceMappingURL=subagent.d.ts.map

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

@@ -0,0 +1,120 @@
+/**
+ * Subagent subject module: declared/resolved/actual payloads, scanner
+ * composition (canonical-extensions + agent-dir × subagent-rendering agents),
+ * and projections via the shared helper.
+ *
+ * Activation comes from the declared `enabled` flag, mirroring skills and
+ * commands. Single-file subagent surfaces (e.g., `roo`'s `.roomodes`) emit
+ * one occurrence per file path; the file itself is the materialization.
+ */
+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.subagents === undefined)
+        return [];
+    return Object.entries(settings.subagents).map(([name, entry]) => ({
+        name: decodeExtensionNameSync(name),
+        entry,
+    }));
+};
+const resolvedFromLockfile = (lockfile) => {
+    if (lockfile.subagents === undefined)
+        return [];
+    return Object.entries(lockfile.subagents).map(([name, lockEntry]) => ({
+        name: decodeExtensionNameSync(name),
+        lockEntry,
+    }));
+};
+const canonicalToActual = (occ, scope) => {
+    const isExternal = occ.origin === "external-axm";
+    const packageRoot = canonicalAxmPackageRoot(occ);
+    return {
+        key: { scope, type: "subagent", name: occ.name },
+        origin: isExternal ? { _tag: "external-axm-subagent" } : { _tag: "canonical-axm-subagent" },
+        contentRoot: occ.contentLocation,
+        sourcePath: Option.getOrNull(occ.subjectFile),
+        packageRoot,
+    };
+};
+const agentDirToActual = (occ, scope) => ({
+    key: { scope, type: "subagent", name: occ.name },
+    origin: { _tag: "agent-subagent-dir", agentId: occ.agentId },
+    contentRoot: occ.contentLocation,
+    // For directory-style subagents the scanner emits `<dir>/${name}.md`; for
+    // single-file surfaces (e.g., `.roomodes`) the scanner emits the file path
+    // itself. Either way `subjectFile` is `Some` for agent-dir subagent occs.
+    sourcePath: Option.getOrNull(occ.subjectFile),
+    packageRoot: null,
+});
+const orphanResolvedWarning = (name) => ({
+    source: "lockfile",
+    message: `subagent: lockfile entry "${name}" has no matching declared or pack-member home`,
+    code: "orphan-resolved",
+});
+const subagentPolicy = (scope) => ({
+    declaredEntries: (d) => d,
+    declaredName: (e) => e.name,
+    declaredActivation: (e) => (e.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: "subagent", name: input.name },
+        installationOrigin: input.installationOrigin,
+        activation: input.activation,
+        resolved: input.resolved,
+        actual: input.actual,
+        providingPacks: input.providingPacks,
+    }),
+    buildUnmanagedRow: (entry) => ({
+        key: { scope, type: "subagent", name: entry.key.name },
+        actual: entry,
+    }),
+    resolvedOrphanWarning: orphanResolvedWarning,
+});
+/**
+ * Build the subagent 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 makeSubagentExtensionsApi = (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 agentDir = yield* scanners.agentDir;
+        const fromCanonical = filterMapOccurrences(canonical, "subagent", (occ) => canonicalToActual(occ, scope));
+        const fromAgentDir = filterMapOccurrences(agentDir, "subagent", (occ) => agentDirToActual(occ, scope));
+        return [...fromCanonical, ...fromAgentDir];
+    });
+    const project = yield* Effect.cached(projectInstalledExtensions({
+        declared,
+        resolved,
+        actual,
+        installedPacks: installedPacks.pipe(Effect.map((packs) => packs.map((p) => ({ ref: p.ref, members: p.subagents })))),
+        packMembers: (pack) => pack.members,
+        packRef: (pack) => pack.ref,
+        policy: subagentPolicy(scope),
+        diagnostics,
+    }));
+    return makeProjectedSubjectCells({
+        declared,
+        resolved,
+        actual,
+        project,
+    });
+});
+//# sourceMappingURL=subagent.js.map

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

@@ -0,0 +1,49 @@
+/**
+ * Agent-directory scanner: enumerates per-agent skill and subagent
+ * directories declared by the existing `AgentRegistry`. Each occurrence
+ * carries an `agent-dir` discriminator parameterized by `agentId` and the
+ * subject `type`.
+ *
+ * Subject coverage in v1:
+ *
+ * - skill — every agent with a non-empty `agent.skills.dir`.
+ * - subagent — every agent with `agent.subagents?.dir`. Single-file
+ *   subagent surfaces (`isFile === true`, e.g., `roo`'s `.roomodes`) emit one
+ *   occurrence per file path; the file itself is the materialization.
+ *
+ * Rules: no agent in the v1 `AgentRegistry` exposes a rules directory, so the
+ * scanner emits no rule occurrences.
+ *
+ * Each occurrence carries structural fields the subject modules need for
+ * cross-platform path handling — `pathSegments` (the absolute path split via
+ * the `Path` service) and `subjectFile` (the canonical primary file inside
+ * the subject directory) — plus a probed `subjectFileExists` flag so subject
+ * modules do not hardcode presence.
+ *
+ * Per Decision 5, scanner output is occurrence-shaped. The public effect
+ * carries no `FileSystem | Path` requirement; per-file partial failures
+ * publish diagnostic warnings rather than failing the cell.
+ *
+ * The scanner avoids `fs.stat` and uses only `fs.exists` / `fs.readDirectory`
+ * so it remains compatible with the fixture builder's in-memory `FileSystem`.
+ */
+import * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import type * as Path from "effect/Path";
+import type { AgentDescriptor, AgentId } from "@agentxm/extension-model/unstable/agents/types";
+import type { Diagnostics } from "../diagnostics.js";
+import type { Scope } from "../types.js";
+import type { AgentDirOccurrence } from "./types.js";
+export interface AgentDirScannerDeps {
+    readonly fs: FileSystem.FileSystem;
+    readonly path: Path.Path;
+    readonly workspaceRoot: string;
+    readonly scope: Scope;
+    readonly diagnostics: Diagnostics;
+    readonly agentRegistry?: Readonly<Partial<Record<AgentId, AgentDescriptor>>>;
+}
+/**
+ * Closure helper: returns the dependency-closed scanner effect.
+ */
+export declare const makeAgentDirScanner: (deps: AgentDirScannerDeps) => Effect.Effect<ReadonlyArray<AgentDirOccurrence>>;
+//# sourceMappingURL=agent-dir.d.ts.map