@agentxm/workspace-inspection 0.28.4-bootstrap.0

package/LICENSE

@@ -0,0 +1,110 @@
+# Functional Source License, Version 1.1, MIT Future License
+
+## Abbreviation
+
+FSL-1.1-MIT
+
+## Notice
+
+Copyright 2025-2026 AgentXM, Inc.
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the MIT license that is effective on the second anniversary of the date we make
+the Software available. On or after that date, you may use the Software under
+the MIT license, in which case the following will apply:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/src/errors.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Typed failures for workspace-inspection queries. The producer owns the
+ * category choice and user-facing wording; the application boundary converts
+ * the carried fields into its error envelope verbatim.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+declare const WorkspaceInspectionFailed_base: Schema.Class<WorkspaceInspectionFailed, Schema.TaggedStruct<"WorkspaceInspectionFailed", {
+    readonly category: Schema.Literals<readonly ["internal", "validation"]>;
+    readonly detail: Schema.String;
+    readonly cause: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A workspace-inspection query could not proceed. `category` and `detail`
+ * carry the boundary rendering 1:1.
+ */
+export declare class WorkspaceInspectionFailed extends WorkspaceInspectionFailed_base {
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/errors.js

@@ -0,0 +1,19 @@
+/**
+ * Typed failures for workspace-inspection queries. The producer owns the
+ * category choice and user-facing wording; the application boundary converts
+ * the carried fields into its error envelope verbatim.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+/**
+ * A workspace-inspection query could not proceed. `category` and `detail`
+ * carry the boundary rendering 1:1.
+ */
+export class WorkspaceInspectionFailed extends Schema.TaggedError()("WorkspaceInspectionFailed", {
+    category: Schema.Literals(["internal", "validation"]),
+    detail: Schema.String,
+    cause: Schema.optional(Schema.Unknown),
+}) {
+}
+//# sourceMappingURL=errors.js.map

package/dist/src/extension-list.d.ts

@@ -0,0 +1,35 @@
+import * as Effect from "effect/Effect";
+import { type InstallableExtensionType } from "@agentxm/extension-model/unstable/extensions/installable-types";
+import type { DeprecationView } from "@agentxm/extension-model/unstable/extensions/deprecation";
+import { SourceHostProviders } from "@agentxm/extension-sources";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { WorkspaceInspectionFailed } from "./errors.js";
+import { InspectionFailureAdapter } from "./failure-adapter.js";
+export type ExtensionListFilter = "all" | "outdated" | "deprecated";
+export type ExtensionAssessmentState = "not-checked" | "current" | "available" | "changed" | "active" | "deprecated" | "unknown" | "not-applicable";
+export interface ExtensionAssessment {
+    readonly state: ExtensionAssessmentState;
+    readonly reason?: string;
+    readonly installedVersion?: string;
+    readonly constraint?: string;
+    readonly latestMatching?: string;
+    readonly latestAvailable?: string;
+    readonly installedRevision?: string;
+    readonly currentRevision?: string;
+    readonly deprecation?: DeprecationView;
+}
+export interface ExtensionListItem {
+    readonly ref: string;
+    readonly type: InstallableExtensionType;
+    readonly name: string;
+    readonly management: "configured" | "implicit" | "unmanaged";
+    readonly installed: boolean;
+    readonly enabled: boolean | null;
+    readonly version?: string;
+    readonly source?: string;
+    readonly sourceName?: string;
+    readonly assessment: ExtensionAssessment;
+}
+export declare const collectExtensionListItems: (type?: "skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | undefined) => Effect.Effect<ExtensionListItem[], import("@agentxm/workspace-state").LockfileIoError | import("@agentxm/workspace-state").LockfileParseError | import("@agentxm/workspace-state").LockfileDecodeError | import("@agentxm/workspace-state").WorkspaceRootEscape | import("@agentxm/workspace-state").SettingsIoError | import("@agentxm/workspace-state").SettingsParseError | import("@agentxm/workspace-state").SettingsDecodeError, WorkspaceMutations>;
+export declare const assessExtensionListItems: (items: readonly ExtensionListItem[], filter: "outdated" | "deprecated") => Effect.Effect<ExtensionListItem[], WorkspaceInspectionFailed | import("@agentxm/workspace-state").LockfileIoError | import("@agentxm/workspace-state").LockfileParseError | import("@agentxm/workspace-state").LockfileDecodeError | import("@agentxm/workspace-state").WorkspaceRootEscape | import("@agentxm/workspace-state").SettingsIoError | import("@agentxm/workspace-state").SettingsParseError | import("@agentxm/workspace-state").SettingsDecodeError | import("@agentxm/registry-client").RegistryProblem | import("@agentxm/registry-client").RegistryRequestFailed | import("@agentxm/registry-client").RegistryOperationFailed, InspectionFailureAdapter | WorkspaceMutations | import("effect/FileSystem").FileSystem | import("effect/unstable/http/HttpClient").HttpClient | import("effect/Path").Path | import("@agentxm/extension-sources").WorkspaceCatalog | SourceHostProviders | import("effect/Scope").Scope>;
+//# sourceMappingURL=extension-list.d.ts.map

package/dist/src/extension-list.js

@@ -0,0 +1,263 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as semver from "semver";
+import { extensionTypeToPlural, parseExtensionFqnParts, parseSourceQualifiedRegistrySourcePatternParts, } from "@agentxm/extension-model/unstable/extensions";
+import { installableExtensionTypes, } from "@agentxm/extension-model/unstable/extensions/installable-types";
+import {} from "@agentxm/extension-model/unstable/extensions/refs/extension-ref";
+import { createRegistryClient } from "@agentxm/registry-client";
+import { resolveSource, SourceHostProviders } from "@agentxm/extension-sources";
+import { printSourceParams } from "@agentxm/extension-model/unstable/sources/printer";
+import { lockEntryToSourceParams } from "@agentxm/workspace-state";
+import { isWorkspaceSourceLocator } from "@agentxm/extension-model/unstable/sources/workspace";
+import { VersionSchema } from "@agentxm/extension-model/unstable/version-constraints";
+import { WorkspaceMutations, } from "@agentxm/workspace-state";
+import { checkCurrency } from "./version-currency/index.js";
+import { WorkspaceInspectionFailed } from "./errors.js";
+import { InspectionFailureAdapter } from "./failure-adapter.js";
+const getAcceptedEntry = (ws, type, name) => {
+    switch (type) {
+        case "skill":
+            return ws.getLockedSkill(name);
+        case "mcp-server":
+            return ws.getLockedMcpServer(name);
+        case "subagent":
+            return ws.getLockedSubagent(name);
+        case "rule":
+            return ws.getLockedRuleEntry(name);
+        case "hook":
+            return ws.getLockedHookEntry(name);
+        case "knowledge":
+            return ws.getLockedKnowledgeEntry(name);
+        case "pack":
+            return ws.getLockedPack(name);
+    }
+};
+const recordSource = (row) => {
+    if (row === undefined)
+        return undefined;
+    const source = row.source;
+    if (source === undefined)
+        return undefined;
+    return typeof source === "string" ? source : Option.getOrUndefined(source);
+};
+const refName = (ref) => {
+    switch (ref.type) {
+        case "skill":
+            return ref.skill.name;
+        case "mcp-server":
+            return ref.server.name;
+        case "subagent":
+            return ref.subagent.name;
+        case "rule":
+            return ref.rule.name;
+        case "hook":
+            return ref.hook.name;
+        case "knowledge":
+            return ref.knowledge.name;
+        case "pack":
+            return ref.pack.name;
+    }
+};
+const inventoryKey = (type, name) => `${type}:${name}`;
+export const collectExtensionListItems = Effect.fn("Workspace.collectExtensionListItems")(function* (type) {
+    const ws = yield* WorkspaceMutations;
+    const inventory = yield* ws.records.getInventory(type === undefined ? {} : { type });
+    const types = type === undefined ? installableExtensionTypes : [type];
+    const rowsByKey = new Map();
+    const rowsByType = yield* Effect.forEach(types, (itemType) => ws.records.rows(itemType), {
+        concurrency: "unbounded",
+    });
+    for (const row of rowsByType.flat()) {
+        rowsByKey.set(inventoryKey(row.type, row.name), row);
+    }
+    const [skills, mcps, subagents, rules, hooks, knowledge, packs] = yield* Effect.all([
+        ws.getLockedSkills(),
+        ws.getLockedMcpServers(),
+        ws.getLockedSubagents(),
+        ws.getLockedRules(),
+        ws.getLockedHooks(),
+        ws.getLockedKnowledge(),
+        ws.getLockedPacks(),
+    ]);
+    const accepted = (itemType, name) => {
+        switch (itemType) {
+            case "skill":
+                return skills[name];
+            case "mcp-server":
+                return mcps[name];
+            case "subagent":
+                return subagents[name];
+            case "rule":
+                return rules[name];
+            case "hook":
+                return hooks[name];
+            case "knowledge":
+                return knowledge[name];
+            case "pack":
+                return packs[name];
+        }
+    };
+    return inventory.items.map((row) => {
+        const locked = accepted(row.type, row.name);
+        const configuredSource = recordSource(rowsByKey.get(inventoryKey(row.type, row.name)));
+        const lockedSource = locked === undefined ? undefined : printSourceParams(lockEntryToSourceParams(locked));
+        const source = configuredSource ?? lockedSource;
+        const identitySource = locked?.type === "registry"
+            ? `${locked.owner}/${extensionTypeToPlural[row.type]}/${locked.name}`
+            : (configuredSource ?? lockedSource);
+        const fqnSource = identitySource !== undefined && isWorkspaceSourceLocator(identitySource)
+            ? identitySource.slice("workspace:".length)
+            : identitySource;
+        const parsed = fqnSource === undefined ? undefined : parseExtensionFqnParts(fqnSource);
+        const ref = parsed === undefined
+            ? `${extensionTypeToPlural[row.type]}/${row.name}`
+            : `${parsed.owner}/${extensionTypeToPlural[parsed.type]}/${parsed.name}`;
+        return {
+            ref,
+            type: row.type,
+            name: row.name,
+            management: row.classification.lifecycle,
+            installed: row.installed,
+            enabled: row.enabled,
+            ...(locked?.type === "registry" ? { version: locked.resolvedVersion } : {}),
+            ...(source === undefined ? {} : { source }),
+            ...(locked?.type === "registry" ? { sourceName: locked.sourceName } : {}),
+            assessment: { state: "not-checked" },
+        };
+    });
+});
+const decodeInstalledVersion = (value, ref) => Schema.decodeUnknownEffect(VersionSchema)(value).pipe(Effect.mapError(() => new WorkspaceInspectionFailed({
+    category: "validation",
+    detail: `Accepted version for ${ref} is invalid`,
+})));
+const constraintFromSource = (source) => {
+    if (source === undefined)
+        return Option.none();
+    const parsed = parseSourceQualifiedRegistrySourcePatternParts(source);
+    return Option.fromUndefinedOr(parsed?.versionRange);
+};
+const registryAssessment = Effect.fn("Workspace.registryExtensionAssessment")(function* (item, filter, record) {
+    const ws = yield* WorkspaceMutations;
+    if (record.type !== "registry") {
+        return {
+            state: "unknown",
+            reason: "Missing accepted Registry identity",
+        };
+    }
+    const identity = { owner: record.owner, type: item.type, name: record.name };
+    const sourceName = record.sourceName;
+    const source = yield* ws.getConfiguredSourceByName(sourceName);
+    if (Option.isNone(source) || source.value.type !== "registry") {
+        return {
+            state: "unknown",
+            reason: `Supplying Registry source "${sourceName}" is not configured`,
+        };
+    }
+    const client = yield* createRegistryClient(source.value.location.href);
+    const index = yield* client.getExtensionIndex({
+        owner: identity.owner,
+        type: identity.type,
+        name: identity.name,
+    });
+    if (Option.isNone(index)) {
+        return {
+            state: "unknown",
+            reason: "Extension index was not found",
+        };
+    }
+    if (filter === "deprecated") {
+        return index.value.deprecation === null
+            ? { state: "active" }
+            : {
+                state: "deprecated",
+                deprecation: index.value.deprecation,
+            };
+    }
+    const installedVersion = yield* decodeInstalledVersion(record.resolvedVersion, item.ref);
+    const constraint = constraintFromSource(item.source);
+    const currency = checkCurrency(installedVersion, constraint, index.value);
+    const updateAvailable = Option.exists(currency.latestMatching, (latestMatching) => semver.gt(latestMatching, installedVersion));
+    return {
+        state: updateAvailable ? "available" : "current",
+        installedVersion,
+        ...Option.match(constraint, {
+            onNone: () => ({}),
+            onSome: (value) => ({ constraint: value }),
+        }),
+        ...Option.match(currency.latestMatching, {
+            onNone: () => ({}),
+            onSome: (value) => ({ latestMatching: value }),
+        }),
+        latestAvailable: currency.latestAvailable,
+    };
+});
+const gitAssessment = Effect.fn("Workspace.gitExtensionAssessment")(function* (item, record) {
+    const providers = yield* SourceHostProviders;
+    const adapter = yield* InspectionFailureAdapter;
+    if (record.type === "registry" || record.type === "local") {
+        return {
+            state: "unknown",
+            reason: "Accepted immutable resolution is missing",
+        };
+    }
+    const source = yield* resolveSource(printSourceParams(lockEntryToSourceParams(record))).pipe(Effect.result);
+    if (source._tag === "Failure") {
+        return {
+            state: "unknown",
+            reason: adapter.describeFailure(source.failure),
+        };
+    }
+    const refs = yield* providers
+        .find(source.success, {
+        names: [item.name],
+        type: item.type,
+        owner: Option.none(),
+        versionRange: Option.none(),
+    })
+        .pipe(Effect.result);
+    if (refs._tag === "Failure") {
+        return {
+            state: "unknown",
+            reason: adapter.describeFailure(refs.failure),
+        };
+    }
+    const match = refs.success.find((ref) => ref.type === item.type && refName(ref) === item.name);
+    if (match === undefined || match.refType !== "git-hosted") {
+        return {
+            state: "unknown",
+            reason: "Source revision could not be compared",
+        };
+    }
+    return {
+        state: match.gitTreeSha === record.resolvedTree && match.gitCommitSha === record.resolvedCommit
+            ? "current"
+            : "changed",
+        installedRevision: `${record.resolvedCommit}:${record.resolvedTree}`,
+        currentRevision: `${match.gitCommitSha}:${match.gitTreeSha}`,
+    };
+});
+const gitAuthorities = new Set(["github", "gitlab", "bitbucket", "azurerepos", "git"]);
+const assessItem = (item, filter, record) => Effect.gen(function* () {
+    if (!item.installed)
+        return { state: "not-applicable" };
+    if (record === undefined) {
+        return {
+            state: "unknown",
+            reason: "Installed extension has no accepted external resolution",
+        };
+    }
+    if (record.type === "registry")
+        return yield* registryAssessment(item, filter, record);
+    if (filter === "outdated" && gitAuthorities.has(record.type)) {
+        return yield* gitAssessment(item, record);
+    }
+    return { state: "not-applicable" };
+});
+export const assessExtensionListItems = Effect.fn("Workspace.assessExtensionListItems")(function* (items, filter) {
+    const ws = yield* WorkspaceMutations;
+    return yield* Effect.forEach(items, (item) => {
+        return getAcceptedEntry(ws, item.type, item.name).pipe(Effect.flatMap((accepted) => assessItem(item, filter, Option.getOrUndefined(accepted))), Effect.map((assessment) => ({ ...item, assessment })));
+    }, { concurrency: 6 });
+});
+//# sourceMappingURL=extension-list.js.map

package/dist/src/failure-adapter.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The application-supplied conversion from typed failures to the diagnostic
+ * sentences inspection results embed as `reason` text. Error rendering is
+ * application-owned: the CLI implements this with the same dispatcher it uses
+ * at its output boundary, so reasons inside assessments stay byte-identical
+ * with rendered errors. The feature keeps only the requirement, never the
+ * mapping.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as ServiceMap from "effect/Context";
+export interface InspectionFailureAdapterService {
+    /** Render a failure as the diagnostic sentence an assessment reports. */
+    readonly describeFailure: (failure: unknown) => string;
+}
+declare const InspectionFailureAdapter_base: ServiceMap.ServiceClass<InspectionFailureAdapter, "@agentxm/workspace-inspection/failure-adapter/InspectionFailureAdapter", InspectionFailureAdapterService>;
+export declare class InspectionFailureAdapter extends InspectionFailureAdapter_base {
+}
+export {};
+//# sourceMappingURL=failure-adapter.d.ts.map

package/dist/src/failure-adapter.js

@@ -0,0 +1,14 @@
+/**
+ * The application-supplied conversion from typed failures to the diagnostic
+ * sentences inspection results embed as `reason` text. Error rendering is
+ * application-owned: the CLI implements this with the same dispatcher it uses
+ * at its output boundary, so reasons inside assessments stay byte-identical
+ * with rendered errors. The feature keeps only the requirement, never the
+ * mapping.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as ServiceMap from "effect/Context";
+export class InspectionFailureAdapter extends ServiceMap.Service()("@agentxm/workspace-inspection/failure-adapter/InspectionFailureAdapter") {
+}
+//# sourceMappingURL=failure-adapter.js.map

package/dist/src/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Workspace-inspection feature: read-only assessment of the workspace's
+ * extension inventory against registries and sources (listing and
+ * version-currency checks).
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { WorkspaceInspectionFailed } from "./errors.js";
+export { InspectionFailureAdapter, type InspectionFailureAdapterService, } from "./failure-adapter.js";
+export { assessExtensionListItems, collectExtensionListItems, type ExtensionAssessment, type ExtensionAssessmentState, type ExtensionListFilter, type ExtensionListItem, } from "./extension-list.js";
+export { checkCurrency, collectAllCurrencyEntries, collectAllUpdateEntries, collectHookCurrency, collectKnowledgeCurrency, collectMcpServerCurrency, collectPackCurrency, collectRuleCurrency, collectSkillCurrency, collectSkillSourceFreshness, collectMcpServerSourceFreshness, collectSubagentSourceFreshness, collectRuleSourceFreshness, collectHookSourceFreshness, collectKnowledgeSourceFreshness, sourceFreshnessCollectors, collectSubagentCurrency, type CurrencyResult, type CurrencyStatus, type ExtensionCurrencyEntry, type ExtensionSourceFreshnessEntry, type ExtensionUpdateEntry, } from "./version-currency/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -0,0 +1,13 @@
+/**
+ * Workspace-inspection feature: read-only assessment of the workspace's
+ * extension inventory against registries and sources (listing and
+ * version-currency checks).
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { WorkspaceInspectionFailed } from "./errors.js";
+export { InspectionFailureAdapter, } from "./failure-adapter.js";
+export { assessExtensionListItems, collectExtensionListItems, } from "./extension-list.js";
+export { checkCurrency, collectAllCurrencyEntries, collectAllUpdateEntries, collectHookCurrency, collectKnowledgeCurrency, collectMcpServerCurrency, collectPackCurrency, collectRuleCurrency, collectSkillCurrency, collectSkillSourceFreshness, collectMcpServerSourceFreshness, collectSubagentSourceFreshness, collectRuleSourceFreshness, collectHookSourceFreshness, collectKnowledgeSourceFreshness, sourceFreshnessCollectors, collectSubagentCurrency, } from "./version-currency/index.js";
+//# sourceMappingURL=index.js.map

package/dist/src/version-currency/check-currency.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Currency assessment for a single extension version.
+ *
+ * Compares an installed version against the versions available in an
+ * ExtensionIndex, respecting an optional version constraint.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Option from "effect/Option";
+import type { Version } from "@agentxm/extension-model/unstable/version-constraints";
+import type { ExtensionIndex } from "@agentxm/registry-protocol/unstable/registry/schema";
+/**
+ * Currency status for a single extension.
+ *
+ * - `current` — installed version matches the latest satisfying version.
+ * - `update-available` — a newer version exists within the same major line.
+ * - `major-update-available` — a newer major version exists.
+ */
+export type CurrencyStatus = "current" | "update-available" | "major-update-available";
+/**
+ * Result of a currency check for a single extension.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface CurrencyResult {
+    readonly status: CurrencyStatus;
+    readonly installedVersion: Version;
+    /** Latest version satisfying the declared constraint. None when no version satisfies. */
+    readonly latestMatching: Option.Option<Version>;
+    /** Absolute latest version in the index (regardless of constraint). */
+    readonly latestAvailable: Version;
+}
+/**
+ * Assess version currency for a single extension.
+ *
+ * @param installedVersion - Currently installed version.
+ * @param constraint - Optional version constraint from settings (e.g. `^1.0.0`).
+ * @param index - Extension index containing all available versions (newest-first).
+ */
+export declare const checkCurrency: (installedVersion: Version, constraint: Option.Option<string>, index: ExtensionIndex) => CurrencyResult;
+//# sourceMappingURL=check-currency.d.ts.map

package/dist/src/version-currency/check-currency.js

@@ -0,0 +1,53 @@
+/**
+ * Currency assessment for a single extension version.
+ *
+ * Compares an installed version against the versions available in an
+ * ExtensionIndex, respecting an optional version constraint.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Option from "effect/Option";
+import * as semver from "semver";
+import { resolveVersionInRange } from "@agentxm/extension-model/unstable/version-constraints";
+import { selectVersion } from "@agentxm/registry-client";
+// ---------------------------------------------------------------------------
+// Logic
+// ---------------------------------------------------------------------------
+/**
+ * Assess version currency for a single extension.
+ *
+ * @param installedVersion - Currently installed version.
+ * @param constraint - Optional version constraint from settings (e.g. `^1.0.0`).
+ * @param index - Extension index containing all available versions (newest-first).
+ */
+export const checkCurrency = (installedVersion, constraint, index) => {
+    const latestEntry = selectVersion(index.versions);
+    // The index should always have at least one version; fall back to installed.
+    const latestAvailable = Option.match(latestEntry, {
+        onNone: () => installedVersion,
+        onSome: (entry) => entry.version,
+    });
+    const matchingEntry = resolveVersionInRange(index.versions, constraint);
+    const latestMatching = Option.map(matchingEntry, (entry) => entry.version);
+    const status = determineStatus(installedVersion, latestMatching, latestAvailable);
+    return { status, installedVersion, latestMatching, latestAvailable };
+};
+const determineStatus = (installed, latestMatching, latestAvailable) => {
+    const installedMajor = semver.major(installed);
+    const availableMajor = semver.major(latestAvailable);
+    if (!semver.gt(latestAvailable, installed)) {
+        return "current";
+    }
+    if (availableMajor > installedMajor) {
+        return "major-update-available";
+    }
+    if (Option.isNone(latestMatching)) {
+        // No matching version found — treat as update-available since latest is same major.
+        return "update-available";
+    }
+    if (semver.gt(latestMatching.value, installed)) {
+        return "update-available";
+    }
+    return "current";
+};
+//# sourceMappingURL=check-currency.js.map

package/dist/src/version-currency/collectors.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Per-type currency collectors and aggregator.
+ *
+ * Reads configured and locked entries from the WorkspaceMutations service, filters to
+ * enabled registry-sourced entries, fetches each extension's index from
+ * RegistryClient, and produces an array of ExtensionCurrencyEntry.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import type { ExtensionType } from "@agentxm/extension-model/unstable/extensions";
+import type { RegistryClient } from "@agentxm/registry-client";
+import { SourceHostProviders } from "@agentxm/extension-sources";
+import { type Version, type VersionRange } from "@agentxm/extension-model/unstable/version-constraints";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { type CurrencyResult } from "./check-currency.js";
+import { WorkspaceInspectionFailed } from "../errors.js";
+import { InspectionFailureAdapter } from "../failure-adapter.js";
+/**
+ * Currency assessment for a single installed extension.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface ExtensionCurrencyEntry {
+    readonly kind: "registry-version";
+    /** Fully-qualified name: `@owner/type/name`. */
+    readonly ref: string;
+    readonly type: ExtensionType;
+    readonly installedVersion: Version;
+    readonly constraint: Option.Option<VersionRange>;
+    readonly currency: CurrencyResult;
+}
+/**
+ * Source freshness assessment for a Git-hosted extension.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface ExtensionSourceFreshnessEntry {
+    readonly kind: "source-freshness";
+    readonly ref: string;
+    readonly type: ExtensionType;
+    readonly source: string;
+    readonly installedTreeHash: Option.Option<string>;
+    readonly currentTreeHash: Option.Option<string>;
+    readonly status: "current" | "changed" | "unknown";
+    readonly reason: Option.Option<string>;
+}
+export type ExtensionUpdateEntry = ExtensionCurrencyEntry | ExtensionSourceFreshnessEntry;
+/**
+ * Compare desired Git-hosted entries against their accepted immutable revision.
+ */
+declare const collectSourceFreshness: (args: {
+    readonly extensionType: ExtensionType;
+}) => Effect.Effect<ExtensionSourceFreshnessEntry[], WorkspaceInspectionFailed | import("@agentxm/workspace-state").LockfileIoError | import("@agentxm/workspace-state").LockfileParseError | import("@agentxm/workspace-state").LockfileDecodeError | import("@agentxm/workspace-state").WorkspaceRootEscape | import("@agentxm/workspace-state").SettingsIoError | import("@agentxm/workspace-state").SettingsParseError | import("@agentxm/workspace-state").SettingsDecodeError, InspectionFailureAdapter | WorkspaceMutations | import("effect/FileSystem").FileSystem | import("effect/unstable/http/HttpClient").HttpClient | import("effect/Path").Path | import("@agentxm/extension-sources").WorkspaceCatalog | SourceHostProviders | import("effect/Scope").Scope>;
+type SourceFreshnessCollector = () => ReturnType<typeof collectSourceFreshness>;
+export declare const collectSkillSourceFreshness: SourceFreshnessCollector;
+export declare const collectMcpServerSourceFreshness: SourceFreshnessCollector;
+export declare const collectSubagentSourceFreshness: SourceFreshnessCollector;
+export declare const collectRuleSourceFreshness: SourceFreshnessCollector;
+export declare const collectHookSourceFreshness: SourceFreshnessCollector;
+export declare const collectKnowledgeSourceFreshness: SourceFreshnessCollector;
+/** Every per-type git-source freshness collector, in catalog order. */
+export declare const sourceFreshnessCollectors: ReadonlyArray<SourceFreshnessCollector>;
+/**
+ * Collect currency entries for all enabled, registry-sourced skills.
+ */
+export declare const collectSkillCurrency: (client: RegistryClient) => Effect.Effect<{
+    kind: "registry-version";
+    ref: string;
+    type: "skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack";
+    installedVersion: string & import("effect/Brand").Brand<"Version">;
+    constraint: Option.Option<string & import("effect/Brand").Brand<"VersionRange">>;
+    currency: CurrencyResult;
+}[], WorkspaceInspectionFailed | import("@agentxm/workspace-state").LockfileIoError | import("@agentxm/workspace-state").LockfileParseError | import("@agentxm/workspace-state").LockfileDecodeError | import("@agentxm/workspace-state").WorkspaceRootEscape | import("@agentxm/workspace-state").SettingsIoError | import("@agentxm/workspace-state").SettingsParseError | import("@agentxm/workspace-state").SettingsDecodeError | import("@agentxm/registry-client").RegistryProblem | import("@agentxm/registry-client").RegistryRequestFailed | import("@agentxm/registry-client").RegistryOperationFailed, WorkspaceMutations>;
+/**
+ * Collect currency entries for all registry-sourced MCP servers.
+ */
+export declare const collectMcpServerCurrency: (client: RegistryClient) => Effect.Effect<{
+    kind: "registry-version";
+    ref: string;
+    type: "skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack";
+    installedVersion: string & import("effect/Brand").Brand<"Version">;
+    constraint: Option.Option<string & import("effect/Brand").Brand<"VersionRange">>;
+    currency: CurrencyResult;
+}[], WorkspaceInspectionFailed | import("@agentxm/workspace-state").LockfileIoError | import("@agentxm/workspace-state").LockfileParseError | import("@agentxm/workspace-state").LockfileDecodeError | import("@agentxm/workspace-state").WorkspaceRootEscape | import("@agentxm/workspace-state").SettingsIoError | import("@agentxm/workspace-state").SettingsParseError | import("@agentxm/workspace-state").SettingsDecodeError | import("@agentxm/registry-client").RegistryProblem | import("@agentxm/registry-client").RegistryRequestFailed | import("@agentxm/registry-client").RegistryOperationFailed, WorkspaceMutations>;
+/**
+ * Collect currency entries for all enabled, registry-sourced subagents.
+ */
+export declare const collectSubagentCurrency: (client: RegistryClient) => Effect.Effect<{
+    kind: "registry-version";
+    ref: string;
+    type: "skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack";
+    installedVersion: string & import("effect/Brand").Brand<"Version">;
+    constraint: Option.Option<string & import("effect/Brand").Brand<"VersionRange">>;
+    currency: CurrencyResult;
+}[], WorkspaceInspectionFailed | import("@agentxm/workspace-state").LockfileIoError | import("@agentxm/workspace-state").LockfileParseError | import("@agentxm/workspace-state").LockfileDecodeError | import("@agentxm/workspace-state").WorkspaceRootEscape | import("@agentxm/workspace-state").SettingsIoError | import("@agentxm/workspace-state").SettingsParseError | import("@agentxm/workspace-state").SettingsDecodeError | import("@agentxm/registry-client").RegistryProblem | import("@agentxm/registry-client").RegistryRequestFailed | import("@agentxm/registry-client").RegistryOperationFailed, WorkspaceMutations>;
+/**
+ * Collect currency entries for all registry-sourced packs.
+ */
+export declare const collectPackCurrency: (client: RegistryClient) => Effect.Effect<{
+    kind: "registry-version";
+    ref: string;
+    type: "skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack";
+    installedVersion: string & import("effect/Brand").Brand<"Version">;
+    constraint: Option.Option<string & import("effect/Brand").Brand<"VersionRange">>;
+    currency: CurrencyResult;
+}[], WorkspaceInspectionFailed | import("@agentxm/workspace-state").LockfileIoError | import("@agentxm/workspace-state").LockfileParseError | import("@agentxm/workspace-state").LockfileDecodeError | import("@agentxm/workspace-state").WorkspaceRootEscape | import("@agentxm/workspace-state").SettingsIoError | import("@agentxm/workspace-state").SettingsParseError | import("@agentxm/workspace-state").SettingsDecodeError | import("@agentxm/registry-client").RegistryProblem | import("@agentxm/registry-client").RegistryRequestFailed | import("@agentxm/registry-client").RegistryOperationFailed, WorkspaceMutations>;
+/**
+ * Collect currency entries for all enabled, registry-sourced rules.
+ */
+export declare const collectRuleCurrency: (client: RegistryClient) => Effect.Effect<{
+    kind: "registry-version";
+    ref: string;
+    type: "skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack";
+    installedVersion: string & import("effect/Brand").Brand<"Version">;
+    constraint: Option.Option<string & import("effect/Brand").Brand<"VersionRange">>;
+    currency: CurrencyResult;
+}[], WorkspaceInspectionFailed | import("@agentxm/workspace-state").LockfileIoError | import("@agentxm/workspace-state").LockfileParseError | import("@agentxm/workspace-state").LockfileDecodeError | import("@agentxm/workspace-state").WorkspaceRootEscape | import("@agentxm/workspace-state").SettingsIoError | import("@agentxm/workspace-state").SettingsParseError | import("@agentxm/workspace-state").SettingsDecodeError | import("@agentxm/registry-client").RegistryProblem | import("@agentxm/registry-client").RegistryRequestFailed | import("@agentxm/registry-client").RegistryOperationFailed, WorkspaceMutations>;
+/**
+ * Collect currency entries for all enabled, registry-sourced hooks.
+ */
+export declare const collectHookCurrency: (client: RegistryClient) => Effect.Effect<{
+    kind: "registry-version";
+    ref: string;
+    type: "skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack";
+    installedVersion: string & import("effect/Brand").Brand<"Version">;
+    constraint: Option.Option<string & import("effect/Brand").Brand<"VersionRange">>;
+    currency: CurrencyResult;
+}[], WorkspaceInspectionFailed | import("@agentxm/workspace-state").LockfileIoError | import("@agentxm/workspace-state").LockfileParseError | import("@agentxm/workspace-state").LockfileDecodeError | import("@agentxm/workspace-state").WorkspaceRootEscape | import("@agentxm/workspace-state").SettingsIoError | import("@agentxm/workspace-state").SettingsParseError | import("@agentxm/workspace-state").SettingsDecodeError | import("@agentxm/registry-client").RegistryProblem | import("@agentxm/registry-client").RegistryRequestFailed | import("@agentxm/registry-client").RegistryOperationFailed, WorkspaceMutations>;
+/**
+ * Collect currency entries for all enabled, registry-sourced knowledge bundles.
+ */
+export declare const collectKnowledgeCurrency: (client: RegistryClient) => Effect.Effect<{
+    kind: "registry-version";
+    ref: string;
+    type: "skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack";
+    installedVersion: string & import("effect/Brand").Brand<"Version">;
+    constraint: Option.Option<string & import("effect/Brand").Brand<"VersionRange">>;
+    currency: CurrencyResult;
+}[], WorkspaceInspectionFailed | import("@agentxm/workspace-state").LockfileIoError | import("@agentxm/workspace-state").LockfileParseError | import("@agentxm/workspace-state").LockfileDecodeError | import("@agentxm/workspace-state").WorkspaceRootEscape | import("@agentxm/workspace-state").SettingsIoError | import("@agentxm/workspace-state").SettingsParseError | import("@agentxm/workspace-state").SettingsDecodeError | import("@agentxm/registry-client").RegistryProblem | import("@agentxm/registry-client").RegistryRequestFailed | import("@agentxm/registry-client").RegistryOperationFailed, WorkspaceMutations>;
+/**
+ * Collect currency entries for all extension types and merge into a single array.
+ */
+export declare const collectAllCurrencyEntries: (client: RegistryClient) => Effect.Effect<{
+    kind: "registry-version";
+    ref: string;
+    type: "skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack";
+    installedVersion: string & import("effect/Brand").Brand<"Version">;
+    constraint: Option.Option<string & import("effect/Brand").Brand<"VersionRange">>;
+    currency: CurrencyResult;
+}[], WorkspaceInspectionFailed | import("@agentxm/workspace-state").LockfileIoError | import("@agentxm/workspace-state").LockfileParseError | import("@agentxm/workspace-state").LockfileDecodeError | import("@agentxm/workspace-state").WorkspaceRootEscape | import("@agentxm/workspace-state").SettingsIoError | import("@agentxm/workspace-state").SettingsParseError | import("@agentxm/workspace-state").SettingsDecodeError | import("@agentxm/registry-client").RegistryProblem | import("@agentxm/registry-client").RegistryRequestFailed | import("@agentxm/registry-client").RegistryOperationFailed, WorkspaceMutations>;
+export declare const collectAllUpdateEntries: (client: RegistryClient) => Effect.Effect<(ExtensionSourceFreshnessEntry | {
+    kind: "registry-version";
+    ref: string;
+    type: "skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack";
+    installedVersion: string & import("effect/Brand").Brand<"Version">;
+    constraint: Option.Option<string & import("effect/Brand").Brand<"VersionRange">>;
+    currency: CurrencyResult;
+})[], WorkspaceInspectionFailed | import("@agentxm/workspace-state").LockfileIoError | import("@agentxm/workspace-state").LockfileParseError | import("@agentxm/workspace-state").LockfileDecodeError | import("@agentxm/workspace-state").WorkspaceRootEscape | import("@agentxm/workspace-state").SettingsIoError | import("@agentxm/workspace-state").SettingsParseError | import("@agentxm/workspace-state").SettingsDecodeError | import("@agentxm/registry-client").RegistryProblem | import("@agentxm/registry-client").RegistryRequestFailed | import("@agentxm/registry-client").RegistryOperationFailed, InspectionFailureAdapter | WorkspaceMutations | import("effect/FileSystem").FileSystem | import("effect/unstable/http/HttpClient").HttpClient | import("effect/Path").Path | import("@agentxm/extension-sources").WorkspaceCatalog | SourceHostProviders | import("effect/Scope").Scope>;
+export {};
+//# sourceMappingURL=collectors.d.ts.map

package/dist/src/version-currency/collectors.js

@@ -0,0 +1,287 @@
+/**
+ * Per-type currency collectors and aggregator.
+ *
+ * Reads configured and locked entries from the WorkspaceMutations service, filters to
+ * enabled registry-sourced entries, fetches each extension's index from
+ * RegistryClient, and produces an array of ExtensionCurrencyEntry.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { parseSourceQualifiedRegistrySourcePatternParts, toExtensionTypePlural, } from "@agentxm/extension-model/unstable/extensions";
+import { resolveSource, SourceHostProviders } from "@agentxm/extension-sources";
+import { VersionSchema, } from "@agentxm/extension-model/unstable/version-constraints";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { isSourcedDesiredExtension } from "@agentxm/workspace-state";
+import { checkCurrency } from "./check-currency.js";
+import { WorkspaceInspectionFailed } from "../errors.js";
+import { InspectionFailureAdapter } from "../failure-adapter.js";
+// Registry currency reads share the same four-request transport cap used by
+// publishing. Git source probes stay serial because each provider may allocate
+// a clone/worktree and no higher subprocess capacity has been established.
+const REGISTRY_READ_CONCURRENCY = 4;
+const SOURCE_FRESHNESS_CONCURRENCY = 1;
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Parse a version constraint from a settings source string like `@acme/skills/code-review@^1.0.0`.
+ */
+const parseConstraintFromSource = (source) => {
+    const parts = parseSourceQualifiedRegistrySourcePatternParts(source);
+    if (parts === undefined)
+        return Option.none();
+    return Option.fromUndefinedOr(parts.versionRange);
+};
+/** Build fully-qualified ref like `@acme/skills/code-review`. */
+const buildFqn = (ownerHandle, type, name) => `${ownerHandle}/${toExtensionTypePlural(type)}/${name}`;
+const getAcceptedResolution = (ws, type, name) => {
+    switch (type) {
+        case "skill":
+            return ws.getLockedSkill(name);
+        case "mcp-server":
+            return ws.getLockedMcpServer(name);
+        case "subagent":
+            return ws.getLockedSubagent(name);
+        case "rule":
+            return ws.getLockedRuleEntry(name);
+        case "hook":
+            return ws.getLockedHookEntry(name);
+        case "knowledge":
+            return ws.getLockedKnowledgeEntry(name);
+        case "pack":
+            return ws.getLockedPack(name);
+    }
+};
+const isGitAcceptedResolution = (entry) => entry.type === "github" ||
+    entry.type === "gitlab" ||
+    entry.type === "bitbucket" ||
+    entry.type === "azurerepos" ||
+    entry.type === "git";
+// ---------------------------------------------------------------------------
+// Generic collector
+// ---------------------------------------------------------------------------
+/**
+ * Collect currency from desired state and accepted Registry resolutions.
+ */
+const collectCurrency = (extensionType, client) => Effect.gen(function* () {
+    const ws = yield* WorkspaceMutations;
+    const graph = yield* ws.getDesiredStateGraph();
+    if (!graph.complete) {
+        return yield* new WorkspaceInspectionFailed({
+            category: "validation",
+            detail: "Cannot assess extension currency while the desired pack graph is incomplete",
+        });
+    }
+    const accepted = yield* Effect.forEach(graph.nodes
+        .filter(isSourcedDesiredExtension)
+        .filter((node) => node.type === extensionType && node.enabled), (node) => getAcceptedResolution(ws, node.type, node.name).pipe(Effect.map((resolution) => ({ node, resolution }))));
+    const eligible = accepted.flatMap(({ node, resolution }) => Option.isSome(resolution) && resolution.value.type === "registry"
+        ? [{ node, resolution: resolution.value }]
+        : []);
+    return yield* Effect.forEach(eligible, ({ node, resolution }) => Effect.gen(function* () {
+        const installedVersion = yield* Schema.decodeUnknownEffect(VersionSchema)(resolution.resolvedVersion).pipe(Effect.mapError(() => new WorkspaceInspectionFailed({
+            category: "validation",
+            detail: `Accepted version for ${node.type} "${node.name}" is invalid`,
+        })));
+        const constraint = parseConstraintFromSource(node.source);
+        const indexOption = yield* client.getExtensionIndex({
+            owner: resolution.owner,
+            type: extensionType,
+            name: resolution.name,
+        });
+        if (Option.isNone(indexOption))
+            return Option.none();
+        const currency = checkCurrency(installedVersion, constraint, indexOption.value);
+        return Option.some({
+            kind: "registry-version",
+            ref: buildFqn(resolution.owner, extensionType, resolution.name),
+            type: extensionType,
+            installedVersion,
+            constraint,
+            currency,
+        });
+    }), { concurrency: REGISTRY_READ_CONCURRENCY }).pipe(Effect.map(Array.getSomes));
+});
+// ---------------------------------------------------------------------------
+// Git-hosted freshness collectors
+// ---------------------------------------------------------------------------
+const sourceFreshnessStatus = (installedTreeHash, currentTreeHash) => {
+    if (Option.isNone(installedTreeHash) || Option.isNone(currentTreeHash))
+        return "unknown";
+    return installedTreeHash.value === currentTreeHash.value ? "current" : "changed";
+};
+const freshnessEntry = ({ localName, extensionType, source, installedTreeHash, currentTreeHash, reason, }) => ({
+    kind: "source-freshness",
+    ref: `${toExtensionTypePlural(extensionType)}/${localName}`,
+    type: extensionType,
+    source,
+    installedTreeHash,
+    currentTreeHash,
+    status: Option.isSome(reason)
+        ? "unknown"
+        : sourceFreshnessStatus(installedTreeHash, currentTreeHash),
+    reason,
+});
+/**
+ * The workspace-facing name a discovered ref carries.
+ *
+ * Each type nests its payload under its own key; a returning switch keeps a new
+ * extension type from silently never matching.
+ */
+const refExtensionName = (ref) => {
+    switch (ref.type) {
+        case "skill":
+            return ref.skill.name;
+        case "mcp-server":
+            return ref.server.name;
+        case "subagent":
+            return ref.subagent.name;
+        case "rule":
+            return ref.rule.name;
+        case "hook":
+            return ref.hook.name;
+        case "knowledge":
+            return ref.knowledge.name;
+    }
+};
+const matchingRefTreeSha = (refs, extensionType, localName) => {
+    const match = refs.find((ref) => ref.refType === "git-hosted" &&
+        ref.type === extensionType &&
+        refExtensionName(ref) === localName);
+    return match === undefined ? Option.none() : Option.some(match.gitTreeSha);
+};
+/**
+ * Compare desired Git-hosted entries against their accepted immutable revision.
+ */
+const collectSourceFreshness = (args) => Effect.gen(function* () {
+    const providers = yield* SourceHostProviders;
+    const ws = yield* WorkspaceMutations;
+    const adapter = yield* InspectionFailureAdapter;
+    const { extensionType } = args;
+    const graph = yield* ws.getDesiredStateGraph();
+    if (!graph.complete) {
+        return yield* new WorkspaceInspectionFailed({
+            category: "validation",
+            detail: "Cannot assess source freshness while the desired pack graph is incomplete",
+        });
+    }
+    const accepted = yield* Effect.forEach(graph.nodes
+        .filter(isSourcedDesiredExtension)
+        .filter((node) => node.type === extensionType && node.enabled), (node) => getAcceptedResolution(ws, node.type, node.name).pipe(Effect.map((resolution) => ({ node, resolution }))));
+    const eligible = accepted.flatMap(({ node, resolution }) => Option.isSome(resolution) && isGitAcceptedResolution(resolution.value)
+        ? [{ node, resolution: resolution.value }]
+        : []);
+    return yield* Effect.forEach(eligible, ({ node, resolution }) => Effect.gen(function* () {
+        const installedTreeHash = Option.some(resolution.resolvedTree);
+        const unresolved = (reason) => freshnessEntry({
+            localName: node.name,
+            extensionType,
+            source: node.source,
+            installedTreeHash,
+            currentTreeHash: Option.none(),
+            reason: Option.some(reason),
+        });
+        const sourceResult = yield* resolveSource(node.source).pipe(Effect.result);
+        if (sourceResult._tag === "Failure") {
+            return unresolved(adapter.describeFailure(sourceResult.failure));
+        }
+        const refsResult = yield* providers
+            .find(sourceResult.success, {
+            names: [node.name],
+            type: extensionType,
+            owner: Option.none(),
+            versionRange: Option.none(),
+        })
+            .pipe(Effect.result);
+        if (refsResult._tag === "Failure") {
+            return unresolved(adapter.describeFailure(refsResult.failure));
+        }
+        return freshnessEntry({
+            localName: node.name,
+            extensionType,
+            source: node.source,
+            installedTreeHash,
+            currentTreeHash: matchingRefTreeSha(refsResult.success, extensionType, node.name),
+            reason: Option.none(),
+        });
+    }), { concurrency: SOURCE_FRESHNESS_CONCURRENCY });
+});
+const makeSourceFreshnessCollector = (extensionType) => () => collectSourceFreshness({ extensionType });
+export const collectSkillSourceFreshness = makeSourceFreshnessCollector("skill");
+export const collectMcpServerSourceFreshness = makeSourceFreshnessCollector("mcp-server");
+export const collectSubagentSourceFreshness = makeSourceFreshnessCollector("subagent");
+export const collectRuleSourceFreshness = makeSourceFreshnessCollector("rule");
+export const collectHookSourceFreshness = makeSourceFreshnessCollector("hook");
+export const collectKnowledgeSourceFreshness = makeSourceFreshnessCollector("knowledge");
+/** Every per-type git-source freshness collector, in catalog order. */
+export const sourceFreshnessCollectors = [
+    collectSkillSourceFreshness,
+    collectMcpServerSourceFreshness,
+    collectSubagentSourceFreshness,
+    collectRuleSourceFreshness,
+    collectHookSourceFreshness,
+    collectKnowledgeSourceFreshness,
+];
+// ---------------------------------------------------------------------------
+// Per-type collectors
+// ---------------------------------------------------------------------------
+/**
+ * Collect currency entries for all enabled, registry-sourced skills.
+ */
+export const collectSkillCurrency = (client) => collectCurrency("skill", client);
+/**
+ * Collect currency entries for all registry-sourced MCP servers.
+ */
+export const collectMcpServerCurrency = (client) => collectCurrency("mcp-server", client);
+/**
+ * Collect currency entries for all enabled, registry-sourced subagents.
+ */
+export const collectSubagentCurrency = (client) => collectCurrency("subagent", client);
+/**
+ * Collect currency entries for all registry-sourced packs.
+ */
+export const collectPackCurrency = (client) => collectCurrency("pack", client);
+/**
+ * Collect currency entries for all enabled, registry-sourced rules.
+ */
+export const collectRuleCurrency = (client) => collectCurrency("rule", client);
+/**
+ * Collect currency entries for all enabled, registry-sourced hooks.
+ */
+export const collectHookCurrency = (client) => collectCurrency("hook", client);
+/**
+ * Collect currency entries for all enabled, registry-sourced knowledge bundles.
+ */
+export const collectKnowledgeCurrency = (client) => collectCurrency("knowledge", client);
+// ---------------------------------------------------------------------------
+// Aggregator
+// ---------------------------------------------------------------------------
+/**
+ * Collect currency entries for all extension types and merge into a single array.
+ */
+export const collectAllCurrencyEntries = (client) => Effect.gen(function* () {
+    const [skills, mcpServers, subagents, packs, rules, hooks, knowledge] = yield* Effect.all([
+        collectSkillCurrency(client),
+        collectMcpServerCurrency(client),
+        collectSubagentCurrency(client),
+        collectPackCurrency(client),
+        collectRuleCurrency(client),
+        collectHookCurrency(client),
+        collectKnowledgeCurrency(client),
+    ], { concurrency: SOURCE_FRESHNESS_CONCURRENCY });
+    return [...skills, ...mcpServers, ...subagents, ...packs, ...rules, ...hooks, ...knowledge];
+});
+export const collectAllUpdateEntries = (client) => Effect.gen(function* () {
+    const [currencyEntries, freshnessByType] = yield* Effect.all([
+        collectAllCurrencyEntries(client),
+        Effect.forEach(sourceFreshnessCollectors, (collect) => collect(), {
+            concurrency: SOURCE_FRESHNESS_CONCURRENCY,
+        }),
+    ], { concurrency: SOURCE_FRESHNESS_CONCURRENCY });
+    return [...currencyEntries, ...freshnessByType.flat()];
+});
+//# sourceMappingURL=collectors.js.map

package/dist/src/version-currency/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Version currency assessment for installed extensions.
+ *
+ * Shared module providing currency checks used by doctor, outdated, and update commands.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { checkCurrency, type CurrencyResult, type CurrencyStatus } from "./check-currency.js";
+export { collectAllCurrencyEntries, collectAllUpdateEntries, collectHookCurrency, collectKnowledgeCurrency, collectMcpServerCurrency, collectPackCurrency, collectRuleCurrency, collectSkillSourceFreshness, collectMcpServerSourceFreshness, collectSubagentSourceFreshness, collectRuleSourceFreshness, collectHookSourceFreshness, collectKnowledgeSourceFreshness, sourceFreshnessCollectors, collectSkillCurrency, collectSubagentCurrency, type ExtensionCurrencyEntry, type ExtensionSourceFreshnessEntry, type ExtensionUpdateEntry, } from "./collectors.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/version-currency/index.js

@@ -0,0 +1,11 @@
+/**
+ * Version currency assessment for installed extensions.
+ *
+ * Shared module providing currency checks used by doctor, outdated, and update commands.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { checkCurrency } from "./check-currency.js";
+export { collectAllCurrencyEntries, collectAllUpdateEntries, collectHookCurrency, collectKnowledgeCurrency, collectMcpServerCurrency, collectPackCurrency, collectRuleCurrency, collectSkillSourceFreshness, collectMcpServerSourceFreshness, collectSubagentSourceFreshness, collectRuleSourceFreshness, collectHookSourceFreshness, collectKnowledgeSourceFreshness, sourceFreshnessCollectors, collectSkillCurrency, collectSubagentCurrency, } from "./collectors.js";
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@agentxm/workspace-inspection",
+  "version": "0.28.4-bootstrap.0",
+  "description": "AXM workspace-inspection feature: list, view, inventory, and version-currency queries for the axm CLI. Unstable and unsupported — use the axm.sh CLI.",
+  "type": "module",
+  "license": "FSL-1.1-MIT",
+  "homepage": "https://axm.sh",
+  "bugs": {
+    "url": "https://github.com/agentxm/axm/issues"
+  },
+  "author": "AgentXM <hello@agentxm.ai> (https://agentxm.ai)",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agentxm/axm.git",
+    "directory": "packages/workspace-inspection"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    }
+  },
+  "files": [
+    "dist/src/",
+    "!**/*.map"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "nx": {
+    "includedScripts": []
+  },
+  "dependencies": {
+    "effect": "4.0.0-rc.112",
+    "semver": "^7.8.5",
+    "@agentxm/extension-sources": "^0.28.4-bootstrap.0",
+    "@agentxm/extension-model": "^0.28.4-bootstrap.0",
+    "@agentxm/extension-workspace": "^0.28.4-bootstrap.0",
+    "@agentxm/registry-protocol": "^0.28.4-bootstrap.0",
+    "@agentxm/registry-client": "^0.28.4-bootstrap.0",
+    "@agentxm/workspace-state": "^0.28.4-bootstrap.0"
+  },
+  "devDependencies": {
+    "@effect/platform-node": "4.0.0-rc.112",
+    "@effect/vitest": "4.0.0-rc.112",
+    "@types/bun": "^1.3.14",
+    "@types/semver": "^7.5.8",
+    "@typescript/native": "npm:typescript@^7.0.2",
+    "typescript": "npm:@typescript/typescript6@^6.0.2",
+    "vitest": "^4.1.10"
+  }
+}