@agentxm/extension-lifecycle 0.28.6 → 0.28.7

package/dist/src/configured-entry-resolution.d.ts

@@ -20,15 +20,16 @@ import type { SubagentExtensionRef } from "@agentxm/extension-model/unstable/ext
 import type { VersionRange } from "@agentxm/extension-model/unstable/version-constraints";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
 import { ExtensionLifecycleFailed } from "./errors.js";
+import { ReleaseAgePosture } from "./release-age-posture.js";
 import { LifecycleFailureAdapter } from "./failure-adapter.js";
 import type { AcceptedCanonicalRefError } from "@agentxm/workspace-state";
 import type { ConfiguredRegistryResolution } from "@agentxm/workspace-state";
-export declare const makeConfiguredReleaseAgeEvaluation: (mode: "enforce" | "ignore") => Effect.Effect<{
+export declare const makeConfiguredReleaseAgeEvaluation: () => Effect.Effect<{
     minimumReleaseAge: import("effect/Duration").Duration;
     evaluatedAt: DateTime.Utc;
-    mode: "enforce" | "ignore";
+    mode: import("./release-age-posture.js").ReleaseAgePostureValue;
     exclude: readonly import("@agentxm/extension-model/unstable/extensions/release-age").ScopedReleaseAgeExcludePattern[];
-}, ExtensionLifecycleFailed | import("@agentxm/workspace-state").WorkspaceSettingsReadFailure, WorkspaceMutations>;
+}, ExtensionLifecycleFailed | import("@agentxm/workspace-state").WorkspaceSettingsReadFailure, ReleaseAgePosture | WorkspaceMutations>;
 export declare const resolveConfiguredRegistryEntry: (name: string, source: string, expectedType: ExtensionType, releaseAgeEvaluation: ReleaseAgeEvaluation) => Effect.Effect<Option.Option<ConfiguredRegistryResolution>, ExtensionLifecycleFailed | SourceResolutionFailure | AcceptedCanonicalRefError, LifecycleFailureAdapter | SourceHostProviders | WorkspaceCatalog | WorkspaceMutations | FileSystem.FileSystem | HttpClient.HttpClient | Path.Path | Scope.Scope>;
 export declare const resolveConfiguredSkill: (name: string, source: string, releaseAgeEvaluation: ReleaseAgeEvaluation) => Effect.Effect<{
     ref: import("@agentxm/extension-model/unstable/extensions/refs/skill").RegistrySkillRef;

package/dist/src/configured-entry-resolution.js

@@ -7,10 +7,12 @@ import { resolveSource, SourceHostProviders, WorkspaceCatalog } from "@agentxm/e
 import { isWorkspaceSourceLocator } from "@agentxm/extension-model/unstable/sources/workspace";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
 import { ExtensionLifecycleFailed } from "./errors.js";
+import { ReleaseAgePosture } from "./release-age-posture.js";
 import { LifecycleFailureAdapter } from "./failure-adapter.js";
 import { acceptedResolutionRef } from "@agentxm/workspace-state";
 import { resolveWorkspaceExtensionRef } from "@agentxm/workspace-state";
-export const makeConfiguredReleaseAgeEvaluation = (mode) => Effect.gen(function* () {
+export const makeConfiguredReleaseAgeEvaluation = () => Effect.gen(function* () {
+    const mode = yield* ReleaseAgePosture;
     const ws = yield* WorkspaceMutations;
     const configured = yield* ws.getMinimumReleaseAge();
     const minimumReleaseAge = parseMinimumReleaseAge(configured);
@@ -61,6 +63,9 @@ const configuredRegistryResolution = (resolution) => Effect.gen(function* () {
             category: "conflict",
             title: "Release held by minimum release age",
             detail: `${resolution.target}@${resolution.candidate.version} is held by the minimum release age until ${resolution.candidate.eligibleAt}`,
+            // Both routes are reachable from wherever the operator is standing:
+            // the exemption is declared once, the flag lasts one run.
+            recover: `Declare ${resolution.target} in minimumReleaseAgeExclude, or rerun this command with --ignore-release-age to take it for this run only.`,
         });
     }
     const holdbacks = resolution.kind === "exempted" || resolution.newerHeld === undefined

package/dist/src/hooks/manager.js

@@ -29,7 +29,7 @@ import { stripFileProtocol } from "../internal/fs-helpers.js";
 import { makeWorkspaceRelativeSourcePath } from "@agentxm/extension-model/unstable/path-types";
 import { decodeRelativePathSync, makeWorkspaceRelativePath, } from "@agentxm/extension-model/unstable/path-types";
 import { decodeVersionSync } from "@agentxm/extension-model/unstable/version-constraints";
-import { makeConfiguredReleaseAgeEvaluation, resolveConfiguredHook, } from "../configured-entry-resolution.js";
+import { usableAcceptedCanonicalRef } from "@agentxm/workspace-state";
 import { coupleLifecycleDependencyFailure } from "../errors.js";
 import { LifecycleFailureAdapter } from "../failure-adapter.js";
 import { HOOK_FALLBACKS_REGION_OWNER, HookManager } from "@agentxm/extension-workspace";
@@ -711,11 +711,17 @@ export const HookManagerLive = Layer.effect(HookManager, Effect.gen(function* ()
             const configured = yield* ws.getConfiguredHookEntries();
             return Option.fromUndefinedOr(configured[target.name]?.source);
         }),
+        /**
+         * Every enabled entry's accepted canonical package, read from accepted
+         * resolution rather than re-resolved from source. Materialization
+         * realizes what the workspace already accepted; going back to the
+         * source would put an unrelated configured entry's release age between
+         * an operator and the extension they are authoring.
+         */
         listMaterializable: Effect.fn("HookManager.listMaterializable")(function* () {
             const configured = yield* ws.getConfiguredHookEntries();
-            const releaseAgeEvaluation = yield* provide(makeConfiguredReleaseAgeEvaluation("enforce")).pipe(Effect.mapError(coupleLifecycleDependencyFailure));
-            const refs = yield* Effect.scoped(Effect.forEach(enabledConfiguredEntries(configured), ([name, entry]) => provide(resolveConfiguredHook(name, entry.source, releaseAgeEvaluation)).pipe(Effect.mapError(coupleLifecycleDependencyFailure), Effect.map(({ ref }) => ref)), { concurrency: "unbounded" }));
-            return refs;
+            const refs = yield* Effect.forEach(enabledConfiguredEntries(configured), ([name]) => provide(usableAcceptedCanonicalRef({ workspace: ws, type: "hook", name }).pipe(Effect.map(Option.filter((ref) => ref.type === "hook")))), { concurrency: "unbounded" });
+            return refs.flatMap((ref) => (Option.isSome(ref) ? [ref.value] : []));
         }),
         materializeUninstall,
         materializeDeactivate,

package/dist/src/index.d.ts

@@ -9,6 +9,7 @@
  * @packageDocumentation
  */
 export { ExtensionLifecycleFailed } from "./errors.js";
+export { ReleaseAgePosture, type ReleaseAgePostureValue } from "./release-age-posture.js";
 export { LifecycleFailureAdapter, withAdaptedStepFailures, type LifecycleFailureAdapterService, } from "./failure-adapter.js";
 export { makeConfiguredReleaseAgeEvaluation, resolveConfiguredHook, resolveConfiguredKnowledge, resolveConfiguredMcpServer, resolveConfiguredPack, resolveConfiguredRegistryEntry, resolveConfiguredRule, resolveConfiguredSkill, resolveConfiguredSubagent, } from "./configured-entry-resolution.js";
 export { CONFIGURED_ENTRY_RESOLUTION_TIMEOUT, withConfiguredEntryResolutionTimeout, } from "./resolution-timeout.js";

package/dist/src/index.js

@@ -9,6 +9,7 @@
  * @packageDocumentation
  */
 export { ExtensionLifecycleFailed } from "./errors.js";
+export { ReleaseAgePosture } from "./release-age-posture.js";
 export { LifecycleFailureAdapter, withAdaptedStepFailures, } from "./failure-adapter.js";
 export { makeConfiguredReleaseAgeEvaluation, resolveConfiguredHook, resolveConfiguredKnowledge, resolveConfiguredMcpServer, resolveConfiguredPack, resolveConfiguredRegistryEntry, resolveConfiguredRule, resolveConfiguredSkill, resolveConfiguredSubagent, } from "./configured-entry-resolution.js";
 export { CONFIGURED_ENTRY_RESOLUTION_TIMEOUT, withConfiguredEntryResolutionTimeout, } from "./resolution-timeout.js";

package/dist/src/knowledge/manager.js

@@ -26,7 +26,7 @@ import { makeWorkspaceRelativeSourcePath } from "@agentxm/extension-model/unstab
 import { recordFootprint } from "@agentxm/workspace-state";
 import { makeWorkspaceRelativePath } from "@agentxm/extension-model/unstable/path-types";
 import { decodeVersionSync } from "@agentxm/extension-model/unstable/version-constraints";
-import { makeConfiguredReleaseAgeEvaluation, resolveConfiguredKnowledge, } from "../configured-entry-resolution.js";
+import { usableAcceptedCanonicalRef } from "@agentxm/workspace-state";
 import { getKnowledgeLockEntries } from "@agentxm/workspace-state";
 import { KnowledgeManager, } from "@agentxm/extension-workspace";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
@@ -667,10 +667,21 @@ export const KnowledgeManagerLive = Layer.effect(KnowledgeManager, Effect.gen(fu
         getConfiguredSource: ({ target }) => ws
             .getConfiguredKnowledgeEntries()
             .pipe(Effect.map((entries) => Option.fromUndefinedOr(entries[target.name]?.source))),
+        /**
+         * Every enabled entry's accepted canonical package, read from accepted
+         * resolution rather than re-resolved from source. Materialization
+         * realizes what the workspace already accepted; going back to the
+         * source would put an unrelated configured entry's release age between
+         * an operator and the extension they are authoring.
+         */
         listMaterializable: () => Effect.gen(function* () {
             const nodes = yield* activeKnowledgeNodes();
-            const releaseAgeEvaluation = yield* provide(makeConfiguredReleaseAgeEvaluation("enforce")).pipe(Effect.mapError(coupleLifecycleDependencyFailure));
-            return yield* Effect.scoped(Effect.forEach(nodes, (node) => provide(resolveConfiguredKnowledge(node.name, node.source, releaseAgeEvaluation)).pipe(Effect.mapError(coupleLifecycleDependencyFailure), Effect.map(({ ref }) => ref)), { concurrency: "unbounded" }));
+            const refs = yield* Effect.forEach(nodes, (node) => provide(usableAcceptedCanonicalRef({
+                workspace: ws,
+                type: "knowledge",
+                name: node.name,
+            }).pipe(Effect.map(Option.filter((ref) => ref.type === "knowledge")))), { concurrency: "unbounded" });
+            return refs.flatMap((ref) => (Option.isSome(ref) ? [ref.value] : []));
         }),
         materializeUninstall,
         materializeDeactivate,

package/dist/src/release-age-posture.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The minimum-release-age gate's posture for one invocation.
+ *
+ * A leaf cannot invent this value: `makeConfiguredReleaseAgeEvaluation` reads
+ * it from context, so every gated code path carries the requirement up to the
+ * command boundary that owns the operator's decision. A command is
+ * gate-blockable precisely when its execution requests this service, which is
+ * what the conformance specification reads instead of a hand-copied list.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as ServiceMap from "effect/Context";
+/**
+ * `"enforce"` withholds a candidate that has not reached the configured
+ * minimum release age; `"ignore"` takes it for this run only. Neither value
+ * changes settings, and a declared exemption outranks both.
+ */
+export type ReleaseAgePostureValue = "enforce" | "ignore";
+declare const ReleaseAgePosture_base: ServiceMap.ServiceClass<ReleaseAgePosture, "axm.sh/extension-lifecycle/ReleaseAgePosture", ReleaseAgePostureValue>;
+export declare class ReleaseAgePosture extends ReleaseAgePosture_base {
+}
+export {};
+//# sourceMappingURL=release-age-posture.d.ts.map

package/dist/src/release-age-posture.js

@@ -0,0 +1,15 @@
+/**
+ * The minimum-release-age gate's posture for one invocation.
+ *
+ * A leaf cannot invent this value: `makeConfiguredReleaseAgeEvaluation` reads
+ * it from context, so every gated code path carries the requirement up to the
+ * command boundary that owns the operator's decision. A command is
+ * gate-blockable precisely when its execution requests this service, which is
+ * what the conformance specification reads instead of a hand-copied list.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as ServiceMap from "effect/Context";
+export class ReleaseAgePosture extends ServiceMap.Service()("axm.sh/extension-lifecycle/ReleaseAgePosture") {
+}
+//# sourceMappingURL=release-age-posture.js.map

package/dist/src/rules/manager.js

@@ -30,8 +30,7 @@ import { removeIfExists } from "@agentxm/workspace-state";
 import { makeWorkspaceRelativePath } from "@agentxm/extension-model/unstable/path-types";
 import { decodeVersionSync } from "@agentxm/extension-model/unstable/version-constraints";
 import { WorkspaceMutations } from "@agentxm/workspace-state";
-import { makeConfiguredReleaseAgeEvaluation, resolveConfiguredRule, } from "../configured-entry-resolution.js";
-import { coupleLifecycleDependencyFailure } from "../errors.js";
+import { usableAcceptedCanonicalRef } from "@agentxm/workspace-state";
 import { LifecycleFailureAdapter } from "../failure-adapter.js";
 import { isObservedInstalled } from "@agentxm/workspace-state";
 import { acceptedCanonicalObservation, prepareAcceptedCanonicalTransition, removableAcceptedCanonicalPath, } from "@agentxm/workspace-state";
@@ -423,11 +422,17 @@ export const RuleManagerLive = Layer.effect(RuleManager, Effect.gen(function* ()
             const configured = yield* ws.getConfiguredRuleEntries();
             return Option.fromUndefinedOr(configured[target.name]?.source);
         }),
+        /**
+         * Every enabled entry's accepted canonical package, read from accepted
+         * resolution rather than re-resolved from source. Materialization
+         * realizes what the workspace already accepted; going back to the
+         * source would put an unrelated configured entry's release age between
+         * an operator and the extension they are authoring.
+         */
         listMaterializable: Effect.fn("RuleManager.listMaterializable")(function* () {
             const configured = yield* ws.getConfiguredRuleEntries();
-            const releaseAgeEvaluation = yield* provide(makeConfiguredReleaseAgeEvaluation("enforce")).pipe(Effect.mapError(coupleLifecycleDependencyFailure));
-            const refs = yield* Effect.scoped(Effect.forEach(enabledConfiguredEntries(configured), ([name, entry]) => provide(resolveConfiguredRule(name, entry.source, releaseAgeEvaluation)).pipe(Effect.mapError(coupleLifecycleDependencyFailure), Effect.map(({ ref }) => ref)), { concurrency: "unbounded" }));
-            return refs;
+            const refs = yield* Effect.forEach(enabledConfiguredEntries(configured), ([name]) => provide(usableAcceptedCanonicalRef({ workspace: ws, type: "rule", name }).pipe(Effect.map(Option.filter((ref) => ref.type === "rule")))), { concurrency: "unbounded" });
+            return refs.flatMap((ref) => (Option.isSome(ref) ? [ref.value] : []));
         }),
         materializeUninstall,
         materializeDeactivate,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentxm/extension-lifecycle",
-  "version": "0.28.6",
+  "version": "0.28.7",
   "description": "AXM extension-lifecycle feature: install, update, uninstall, enable, and disable policy across root and type-specific command forms for the axm CLI. Unstable and unsupported — use the axm.sh CLI.",
   "type": "module",
   "license": "FSL-1.1-MIT",
@@ -43,13 +43,13 @@
   "dependencies": {
     "effect": "4.0.0-rc.112",
     "semver": "^7.8.5",
-    "@agentxm/extension-sources": "^0.28.6",
-    "@agentxm/extension-model": "^0.28.6",
-    "@agentxm/extension-workspace": "^0.28.6",
-    "@agentxm/registry-client": "^0.28.6",
-    "@agentxm/workspace-operations": "^0.28.6",
-    "@agentxm/workspace-state": "^0.28.6",
-    "@agentxm/registry-protocol": "^0.28.6"
+    "@agentxm/extension-model": "^0.28.7",
+    "@agentxm/extension-workspace": "^0.28.7",
+    "@agentxm/registry-protocol": "^0.28.7",
+    "@agentxm/registry-client": "^0.28.7",
+    "@agentxm/workspace-state": "^0.28.7",
+    "@agentxm/workspace-operations": "^0.28.7",
+    "@agentxm/extension-sources": "^0.28.7"
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.0-rc.112",