@agentxm/extension-lifecycle 0.28.12 → 0.28.13

package/dist/src/update/configured.js

@@ -0,0 +1,546 @@
+/**
+ * The configured-entry sweep an update performs.
+ *
+ * A workspace-wide update — and every `<type> update` that narrows it — asks
+ * one question of each configured, enabled entry: given the source the
+ * workspace declared and the constraint it recorded, which visible version
+ * does that source resolve to now, and does it differ from the one already
+ * accepted? A workspace-authored entry is locally authoritative and is
+ * reported unchanged rather than re-resolved; an inline MCP connection has no
+ * source to advance; an entry whose source cannot be resolved is reported as
+ * a blocked unit rather than failing the sweep, so one unreachable Registry
+ * does not stop every other advance.
+ *
+ * Each entry is planned through the same per-type install planner the install
+ * routes use, because advancing an accepted resolution is installing the
+ * version the source now offers. Where a direct declaration and a Pack-owned
+ * dependency both plan the same target, the direct one wins: the workspace's
+ * own declaration outranks a dependency the closure derived.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as DateTime from "effect/DateTime";
+import * as Option from "effect/Option";
+import { makeConfiguredReleaseAgeEvaluation, normalizeReleaseAgeRecords, ReleaseAgePosture, resolveConfiguredHook, resolveConfiguredKnowledge, resolveConfiguredMcpServer, resolveConfiguredPack, resolveConfiguredRegistryEntry, resolveConfiguredRule, resolveConfiguredSkill, resolveConfiguredSubagent, } from "@agentxm/extension-resolution";
+import {} from "@agentxm/extension-model/unstable/extensions/release-age";
+import { operationPresentation, } from "@agentxm/workspace-operations";
+import { WorkspaceMutations, configuredRowsByName, isSourcedDesiredExtension, } from "@agentxm/workspace-state";
+import { installableExtensionTypes, toInstallableExtensionTypePlural, } from "@agentxm/extension-model/unstable/extensions/installable-types";
+import {} from "@agentxm/extension-model/unstable/extensions/refs/extension-ref";
+import {} from "@agentxm/extension-model/unstable/workspace-scope";
+import { HookManager, KnowledgeManager, McpServerManager, PackManager, RuleManager, SkillManager, SubagentManager, } from "@agentxm/extension-materialization";
+import { SourceHostProviders, WorkspaceCatalog } from "@agentxm/extension-sources";
+import { enabledConfiguredEntries } from "@agentxm/workspace-state";
+import { extensionTypePluralSentenceLabels } from "@agentxm/extension-model/unstable/extensions";
+import { isWorkspaceSourceLocator } from "@agentxm/extension-model/unstable/sources/workspace";
+import { inlineMcpNotApplicablePlan } from "../install/inline-mcp-operation.js";
+import { decodeExtensionNameSync } from "@agentxm/extension-model/unstable/extensions/common";
+import { ExtensionLifecycleFailed } from "../errors.js";
+import { lifecycleStepFailure } from "../step-failure.js";
+import { StepFailureConversion } from "../step-failure-conversion.js";
+import { planHookInstall } from "../hooks/install/plan.js";
+import { planKnowledgeInstall } from "../knowledge/install/plan.js";
+import { planMcpServerInstall } from "../mcps/install/plan.js";
+import { planPackInstall } from "../packs/install/plan.js";
+import { planRuleInstall } from "../rules/install/plan.js";
+import { planSkillInstall } from "../skills/install/plan.js";
+import { planSubagentInstall } from "../subagents/install/plan.js";
+import { configuredPackConstraintBlockPlan, prospectivePackConstraintProblems, } from "../packs/constraint-gate.js";
+import { WORKSPACE_UPDATE_EXECUTION_CAPABILITIES } from "./atomicity.js";
+const selectedEntries = (entries, selection) => {
+    const { names } = selection;
+    if (names === undefined)
+        return entries;
+    return entries.filter(([name]) => names.has(name));
+};
+const hasConfiguredSource = (entry) => entry[1].source !== undefined;
+const noConfiguredMessage = (type) => Option.match(type, {
+    onNone: () => "No configured extensions.",
+    onSome: (value) => `No configured ${extensionTypePluralSentenceLabels[toInstallableExtensionTypePlural(value)]}.`,
+});
+const flattenPlanSteps = (plan) => plan.jobs.flatMap((job) => job.steps);
+const workspaceSourceUnchangedPlan = (type, name, source, scope) => ({
+    _tag: "Plan",
+    name: `Skip workspace-sourced ${type}`,
+    description: Option.some(`${name} is locally authoritative`),
+    jobs: [
+        {
+            concurrency: 1,
+            steps: [
+                {
+                    key: `${type}:${name}`,
+                    readiness: "ready",
+                    label: name,
+                    run: Effect.succeed({
+                        result: "success",
+                        message: `${name} is workspace-sourced and unchanged`,
+                        artifact: {
+                            path: source,
+                            scope,
+                            change: "unchanged",
+                            targets: [{ path: source, change: "unchanged" }],
+                        },
+                    }),
+                },
+            ],
+        },
+    ],
+});
+const workspacePlanningErrorPlan = (type, name, error) => ({
+    _tag: "Plan",
+    name: `Block configured ${type} update`,
+    description: Option.some(`${name} could not be planned`),
+    jobs: [
+        {
+            concurrency: 1,
+            steps: [
+                {
+                    key: `${type}:${name}:planning-error`,
+                    readiness: "ready",
+                    label: name,
+                    run: Effect.fail(lifecycleStepFailure(error)),
+                },
+            ],
+        },
+    ],
+});
+const toCollectedWorkspaceUpdatePlans = ({ plans, holdbacks = [], bypasses = [], originForStep = () => "direct", }) => ({
+    plans,
+    holdbacks,
+    bypasses,
+    fragments: plans.flatMap((plan) => flattenPlanSteps(plan).map((step, index) => ({
+        key: step.key ?? step.label,
+        origin: originForStep(index),
+        step,
+    }))),
+});
+const releaseAgeRecord = (args) => ({
+    reason: "minimum-release-age",
+    target: args.target,
+    dependencyPath: [args.target],
+    ...(Option.isSome(args.versionRange) ? { requestedRange: args.versionRange.value } : {}),
+    ...(args.selectedVersion === undefined ? {} : { selectedVersion: args.selectedVersion }),
+    ...(args.currentVersion === undefined ? {} : { currentVersion: args.currentVersion }),
+    candidateVersion: args.evidence.version,
+    publishedAt: args.evidence.publishedAt,
+    eligibleAt: args.evidence.eligibleAt,
+    minimumReleaseAgeSeconds: args.evidence.minimumReleaseAgeSeconds,
+});
+const matchesRequestedType = (requestedType, candidate) => Option.match(requestedType, {
+    onNone: () => true,
+    onSome: (value) => value === candidate,
+});
+const mergeFragments = (collections) => {
+    const byKey = new Map();
+    for (const fragment of collections.flatMap((collection) => collection.fragments)) {
+        const existing = byKey.get(fragment.key);
+        if (existing === undefined) {
+            byKey.set(fragment.key, fragment);
+            continue;
+        }
+        if (existing.origin === "dependency" && fragment.origin === "direct") {
+            byKey.set(fragment.key, fragment);
+        }
+    }
+    return [...byKey.values()];
+};
+const resolveUpdateIntent = (args) => Effect.gen(function* () {
+    const registryResolution = yield* resolveConfiguredRegistryEntry(args.name, args.source, args.type, args.releaseAgeEvaluation);
+    if (Option.isSome(registryResolution)) {
+        const resolution = registryResolution.value;
+        if (resolution.kind === "not_found") {
+            return yield* new ExtensionLifecycleFailed({
+                category: "not_found",
+                detail: `Configured extension "${resolution.target}" could not be found in its source`,
+                suggestions: [{ description: "Verify the configured source or update axm.json." }],
+            });
+        }
+        if (resolution.kind === "version_unsatisfied") {
+            return yield* new ExtensionLifecycleFailed({
+                category: "conflict",
+                title: "No compatible version",
+                detail: `${resolution.target} has no visible version satisfying ${resolution.requestedRange}`,
+            });
+        }
+        if (resolution.kind === "policy_held") {
+            return {
+                kind: "policy_held",
+                holdbacks: [
+                    releaseAgeRecord({
+                        target: resolution.target,
+                        versionRange: resolution.versionRange,
+                        evidence: resolution.candidate,
+                    }),
+                ],
+            };
+        }
+        const intent = args.makeIntent(resolution.ref, resolution.versionRange);
+        if (intent === undefined) {
+            return yield* new ExtensionLifecycleFailed({
+                category: "internal",
+                detail: `Configured ${args.type} resolution returned ${resolution.ref.type}`,
+            });
+        }
+        return {
+            kind: "selected",
+            intent,
+            holdbacks: resolution.kind === "exempted" || resolution.newerHeld === undefined
+                ? []
+                : [
+                    releaseAgeRecord({
+                        target: resolution.target,
+                        versionRange: resolution.versionRange,
+                        evidence: resolution.newerHeld,
+                        selectedVersion: resolution.ref.version,
+                        ...(resolution.acceptedVersion === undefined
+                            ? {}
+                            : { currentVersion: resolution.acceptedVersion }),
+                    }),
+                ],
+            bypasses: resolution.kind === "selected"
+                ? []
+                : [
+                    {
+                        ...releaseAgeRecord({
+                            target: resolution.target,
+                            versionRange: resolution.versionRange,
+                            evidence: resolution.bypassed,
+                            selectedVersion: resolution.ref.version,
+                        }),
+                        ...resolution.exemption,
+                    },
+                ],
+        };
+    }
+    const resolved = yield* args.fallback;
+    const intent = args.makeIntent(resolved.ref, resolved.versionRange);
+    if (intent === undefined) {
+        return yield* new ExtensionLifecycleFailed({
+            category: "internal",
+            detail: `Configured ${args.type} resolution returned ${resolved.ref.type}`,
+        });
+    }
+    return {
+        kind: "selected",
+        intent,
+        holdbacks: resolved.releaseAge?.holdbacks ?? [],
+        bypasses: resolved.releaseAge?.bypasses ?? [],
+    };
+});
+const resolveSkillIntent = (name, source, releaseAgeEvaluation) => resolveUpdateIntent({
+    type: "skill",
+    name,
+    source,
+    releaseAgeEvaluation,
+    fallback: resolveConfiguredSkill(name, source, releaseAgeEvaluation),
+    makeIntent: (ref, versionRange) => ref.type === "skill"
+        ? { skillsToInstall: [{ ref, versionRange }] }
+        : undefined,
+});
+const resolveSubagentIntent = (name, source, releaseAgeEvaluation) => resolveUpdateIntent({
+    type: "subagent",
+    name,
+    source,
+    releaseAgeEvaluation,
+    fallback: resolveConfiguredSubagent(name, source, releaseAgeEvaluation),
+    makeIntent: (ref, versionRange) => ref.type === "subagent"
+        ? { subagentsToInstall: [{ ref, versionRange }] }
+        : undefined,
+});
+const resolveRuleIntent = (name, source, releaseAgeEvaluation) => resolveUpdateIntent({
+    type: "rule",
+    name,
+    source,
+    releaseAgeEvaluation,
+    fallback: resolveConfiguredRule(name, source, releaseAgeEvaluation),
+    makeIntent: (ref, versionRange) => ref.type === "rule"
+        ? { refs: [{ ref, versionRange }] }
+        : undefined,
+});
+const resolveHookIntent = (name, source, releaseAgeEvaluation) => resolveUpdateIntent({
+    type: "hook",
+    name,
+    source,
+    releaseAgeEvaluation,
+    fallback: resolveConfiguredHook(name, source, releaseAgeEvaluation),
+    makeIntent: (ref, versionRange) => ref.type === "hook"
+        ? { refs: [{ ref, versionRange }] }
+        : undefined,
+});
+const resolveKnowledgeIntent = (name, source, releaseAgeEvaluation) => resolveUpdateIntent({
+    type: "knowledge",
+    name,
+    source,
+    releaseAgeEvaluation,
+    fallback: resolveConfiguredKnowledge(name, source, releaseAgeEvaluation),
+    makeIntent: (ref, versionRange) => ref.type === "knowledge"
+        ? { refs: [{ ref, versionRange }] }
+        : undefined,
+});
+const resolveMcpServerIntent = (name, source, releaseAgeEvaluation, nonInteractive) => resolveUpdateIntent({
+    type: "mcp-server",
+    name,
+    source,
+    releaseAgeEvaluation,
+    fallback: resolveConfiguredMcpServer(name, source, releaseAgeEvaluation),
+    makeIntent: (ref, versionRange) => ref.type === "mcp-server"
+        ? {
+            ref,
+            localName: decodeExtensionNameSync(name),
+            versionRange,
+            force: false,
+            nonInteractive,
+        }
+        : undefined,
+});
+const resolvePackRef = (name, source, releaseAgeEvaluation, nonInteractive) => resolveUpdateIntent({
+    type: "pack",
+    name,
+    source,
+    releaseAgeEvaluation,
+    fallback: resolveConfiguredPack(name, source, releaseAgeEvaluation),
+    makeIntent: (ref, versionRange) => ref.type === "pack"
+        ? {
+            packToInstall: ref,
+            versionRange,
+            unattended: true,
+            nonInteractive,
+            releaseAgeEvaluation,
+            releaseAgeHoldbackBehavior: "continue",
+        }
+        : undefined,
+});
+const collectResolvedPlan = (resolution, buildPlan, onError) => resolution.pipe(Effect.flatMap((resolved) => resolved.kind === "policy_held"
+    ? Effect.succeed({
+        plans: [],
+        holdbacks: resolved.holdbacks,
+        bypasses: [],
+    })
+    : buildPlan(resolved.intent).pipe(Effect.map((plan) => ({
+        plans: [plan],
+        holdbacks: [...resolved.holdbacks, ...(plan.releaseAge?.holdbacks ?? [])],
+        bypasses: [...resolved.bypasses, ...(plan.releaseAge?.bypasses ?? [])],
+    })))), 
+// One entry that cannot be planned is a blocked unit, not a failed sweep:
+// the other configured entries still have an advance to report.
+Effect.catch((error) => Effect.succeed({
+    plans: [onError(error)],
+    holdbacks: [],
+    bypasses: [],
+})));
+const collectedWorkspaceSourcePlan = (plan) => ({
+    plans: [plan],
+    holdbacks: [],
+    bypasses: [],
+});
+const collectSkillPlans = (selection) => Effect.gen(function* () {
+    const ws = yield* WorkspaceMutations;
+    const configured = yield* ws.records.rows("skill").pipe(Effect.map(configuredRowsByName));
+    const entries = selectedEntries(enabledConfiguredEntries(configured), selection).filter(hasConfiguredSource);
+    const resolved = yield* Effect.forEach(entries, ([name, entry]) => isWorkspaceSourceLocator(entry.source)
+        ? Effect.succeed(collectedWorkspaceSourcePlan(workspaceSourceUnchangedPlan("skill", name, entry.source, ws.scope)))
+        : collectResolvedPlan(resolveSkillIntent(name, entry.source, selection.releaseAgeEvaluation), (intent) => planSkillInstall(intent), (error) => workspacePlanningErrorPlan("skill", name, error)), { concurrency: "unbounded" });
+    return toCollectedWorkspaceUpdatePlans({
+        plans: resolved.flatMap((item) => item.plans),
+        holdbacks: resolved.flatMap((item) => item.holdbacks),
+        bypasses: resolved.flatMap((item) => item.bypasses),
+    });
+});
+const collectRulePlans = (selection) => Effect.gen(function* () {
+    const ws = yield* WorkspaceMutations;
+    const configured = yield* ws.getConfiguredRuleEntries();
+    const entries = selectedEntries(enabledConfiguredEntries(configured), selection);
+    const resolved = yield* Effect.forEach(entries, ([name, entry]) => isWorkspaceSourceLocator(entry.source)
+        ? Effect.succeed(collectedWorkspaceSourcePlan(workspaceSourceUnchangedPlan("rule", name, entry.source, ws.scope)))
+        : collectResolvedPlan(resolveRuleIntent(name, entry.source, selection.releaseAgeEvaluation), (intent) => planRuleInstall(intent), (error) => workspacePlanningErrorPlan("rule", name, error)), { concurrency: "unbounded" });
+    return toCollectedWorkspaceUpdatePlans({
+        plans: resolved.flatMap((item) => item.plans),
+        holdbacks: resolved.flatMap((item) => item.holdbacks),
+        bypasses: resolved.flatMap((item) => item.bypasses),
+    });
+});
+const collectHookPlans = (selection) => Effect.gen(function* () {
+    const ws = yield* WorkspaceMutations;
+    const configured = yield* ws.getConfiguredHookEntries();
+    const entries = selectedEntries(enabledConfiguredEntries(configured), selection);
+    const resolved = yield* Effect.forEach(entries, ([name, entry]) => isWorkspaceSourceLocator(entry.source)
+        ? Effect.succeed(collectedWorkspaceSourcePlan(workspaceSourceUnchangedPlan("hook", name, entry.source, ws.scope)))
+        : collectResolvedPlan(resolveHookIntent(name, entry.source, selection.releaseAgeEvaluation), (intent) => planHookInstall(intent), (error) => workspacePlanningErrorPlan("hook", name, error)), { concurrency: "unbounded" });
+    return toCollectedWorkspaceUpdatePlans({
+        plans: resolved.flatMap((item) => item.plans),
+        holdbacks: resolved.flatMap((item) => item.holdbacks),
+        bypasses: resolved.flatMap((item) => item.bypasses),
+    });
+});
+const collectKnowledgePlans = (selection) => Effect.gen(function* () {
+    const ws = yield* WorkspaceMutations;
+    const configured = yield* ws.getConfiguredKnowledgeEntries();
+    const entries = selectedEntries(enabledConfiguredEntries(configured), selection);
+    const resolved = yield* Effect.forEach(entries, ([name, entry]) => isWorkspaceSourceLocator(entry.source)
+        ? Effect.succeed(collectedWorkspaceSourcePlan(workspaceSourceUnchangedPlan("knowledge", name, entry.source, ws.scope)))
+        : collectResolvedPlan(resolveKnowledgeIntent(name, entry.source, selection.releaseAgeEvaluation), (intent) => planKnowledgeInstall(intent), (error) => workspacePlanningErrorPlan("knowledge", name, error)), { concurrency: "unbounded" });
+    return toCollectedWorkspaceUpdatePlans({
+        plans: resolved.flatMap((item) => item.plans),
+        holdbacks: resolved.flatMap((item) => item.holdbacks),
+        bypasses: resolved.flatMap((item) => item.bypasses),
+    });
+});
+const collectSubagentPlans = (selection) => Effect.gen(function* () {
+    const ws = yield* WorkspaceMutations;
+    const configured = yield* ws.records.rows("subagent").pipe(Effect.map(configuredRowsByName));
+    const entries = selectedEntries(enabledConfiguredEntries(configured), selection).filter(hasConfiguredSource);
+    const resolved = yield* Effect.forEach(entries, ([name, entry]) => isWorkspaceSourceLocator(entry.source)
+        ? Effect.succeed(collectedWorkspaceSourcePlan(workspaceSourceUnchangedPlan("subagent", name, entry.source, ws.scope)))
+        : collectResolvedPlan(resolveSubagentIntent(name, entry.source, selection.releaseAgeEvaluation), (intent) => planSubagentInstall(intent), (error) => workspacePlanningErrorPlan("subagent", name, error)), { concurrency: "unbounded" });
+    return toCollectedWorkspaceUpdatePlans({
+        plans: resolved.flatMap((item) => item.plans),
+        holdbacks: resolved.flatMap((item) => item.holdbacks),
+        bypasses: resolved.flatMap((item) => item.bypasses),
+    });
+});
+const collectMcpServerPlans = (selection) => Effect.gen(function* () {
+    const ws = yield* WorkspaceMutations;
+    const configured = yield* ws.records.rows("mcp-server").pipe(Effect.map(configuredRowsByName));
+    const graph = yield* ws.getDesiredStateGraph();
+    const seenSourceClosures = new Set();
+    const entries = selectedEntries(enabledConfiguredEntries(configured), selection).flatMap((entry) => {
+        const [name, configuredEntry] = entry;
+        const desired = graph.nodes.find((node) => node.type === "mcp-server" && node.name === name);
+        if (configuredEntry.source === undefined ||
+            isWorkspaceSourceLocator(configuredEntry.source) ||
+            desired === undefined ||
+            !isSourcedDesiredExtension(desired)) {
+            return [entry];
+        }
+        if (seenSourceClosures.has(desired.identity))
+            return [];
+        seenSourceClosures.add(desired.identity);
+        const representative = [name, { ...configuredEntry, source: desired.source }];
+        return [representative];
+    });
+    const resolved = yield* Effect.forEach(entries, ([name, entry]) => entry.source === undefined
+        ? Effect.succeed(collectedWorkspaceSourcePlan(inlineMcpNotApplicablePlan(name, "update")))
+        : isWorkspaceSourceLocator(entry.source)
+            ? Effect.succeed(collectedWorkspaceSourcePlan(workspaceSourceUnchangedPlan("mcp-server", name, entry.source, ws.scope)))
+            : collectResolvedPlan(resolveMcpServerIntent(name, entry.source, selection.releaseAgeEvaluation, selection.nonInteractive), (intent) => planMcpServerInstall(intent), (error) => workspacePlanningErrorPlan("mcp-server", name, error)), { concurrency: "unbounded" });
+    return toCollectedWorkspaceUpdatePlans({
+        plans: resolved.flatMap((item) => item.plans),
+        holdbacks: resolved.flatMap((item) => item.holdbacks),
+        bypasses: resolved.flatMap((item) => item.bypasses),
+    });
+});
+const collectPackPlans = (selection) => Effect.gen(function* () {
+    const ws = yield* WorkspaceMutations;
+    const configured = yield* ws.records.rows("pack").pipe(Effect.map(configuredRowsByName));
+    const entries = selectedEntries(Object.entries(configured), selection).filter(hasConfiguredSource);
+    const resolved = yield* Effect.forEach(entries, ([name, entry]) => isWorkspaceSourceLocator(entry.source)
+        ? Effect.succeed({
+            kind: "planned",
+            collection: collectedWorkspaceSourcePlan(workspaceSourceUnchangedPlan("pack", name, entry.source, ws.scope)),
+        })
+        : resolvePackRef(name, entry.source, selection.releaseAgeEvaluation, selection.nonInteractive).pipe(Effect.map((resolution) => ({
+            kind: "resolved",
+            resolution,
+        })), Effect.catch((error) => Effect.succeed({
+            kind: "planned",
+            collection: toCollectedWorkspaceUpdatePlans({
+                plans: [workspacePlanningErrorPlan("pack", name, error)],
+            }),
+        }))), { concurrency: "unbounded" });
+    const selected = resolved.flatMap((item) => item.kind === "resolved" && item.resolution.kind === "selected" ? [item.resolution] : []);
+    const prospectivePacks = selected.map(({ intent }) => intent.packToInstall);
+    const constraintProblems = yield* prospectivePackConstraintProblems({
+        workspace: ws,
+        prospectivePacks,
+        ...(selection.names === undefined ? {} : { selectedNames: selection.names }),
+    });
+    const resolvedHoldbacks = resolved.flatMap((item) => item.kind === "resolved" ? item.resolution.holdbacks : item.collection.holdbacks);
+    const resolvedBypasses = resolved.flatMap((item) => item.kind === "resolved" && item.resolution.kind === "selected"
+        ? item.resolution.bypasses
+        : item.kind === "planned"
+            ? item.collection.bypasses
+            : []);
+    if (constraintProblems.length > 0) {
+        return toCollectedWorkspaceUpdatePlans({
+            plans: [
+                configuredPackConstraintBlockPlan({
+                    operation: "update",
+                    problems: constraintProblems,
+                }),
+            ],
+            holdbacks: resolvedHoldbacks,
+            bypasses: resolvedBypasses,
+        });
+    }
+    const selectedPlans = yield* Effect.forEach(selected, ({ intent }) => planPackInstall(intent), {
+        concurrency: "unbounded",
+    });
+    const plannedCollections = resolved.flatMap((item) => item.kind === "planned" ? [item.collection] : []);
+    return toCollectedWorkspaceUpdatePlans({
+        plans: [...plannedCollections.flatMap((collection) => collection.plans), ...selectedPlans],
+        holdbacks: resolvedHoldbacks,
+        bypasses: resolvedBypasses,
+        originForStep: (index) => (index === 0 ? "direct" : "dependency"),
+    });
+});
+// Total over InstallableExtensionType: a missing key is a compile error, so a
+// type can never again be silently dropped from workspace update.
+const makeWorkspaceUpdateCollectors = () => {
+    const collectorsByType = {
+        skill: collectSkillPlans,
+        rule: collectRulePlans,
+        hook: collectHookPlans,
+        knowledge: collectKnowledgePlans,
+        subagent: collectSubagentPlans,
+        "mcp-server": collectMcpServerPlans,
+        pack: collectPackPlans,
+    };
+    return installableExtensionTypes.map((type) => ({
+        type,
+        collect: collectorsByType[type],
+    }));
+};
+export const makeWorkspaceUpdatePlan = (name, description, steps, type, releaseAge) => ({
+    _tag: "Plan",
+    name,
+    description,
+    executionCapabilities: WORKSPACE_UPDATE_EXECUTION_CAPABILITIES,
+    presentation: operationPresentation({ imperative: "update", past: "Updated", gerund: "Updating" }, Option.getOrUndefined(type)),
+    jobs: [{ concurrency: 1, executionPolicy: "best-effort", steps }],
+    ...(releaseAge === undefined ? {} : { releaseAge }),
+});
+/**
+ * Sweep every selected configured entry and fold the surviving steps into one
+ * best-effort plan, or report that the selection had nothing configured to
+ * advance.
+ */
+export const buildWorkspaceUpdatePlan = Effect.fn("UpdateExtensions.sweepConfigured")(function* (args) {
+    const releaseAgeEvaluation = yield* makeConfiguredReleaseAgeEvaluation();
+    const selection = {
+        names: args.names === undefined ? undefined : new Set(args.names),
+        releaseAgeEvaluation,
+        nonInteractive: args.nonInteractive,
+    };
+    const selectedCollectors = makeWorkspaceUpdateCollectors().filter(({ type }) => matchesRequestedType(args.type, type));
+    const collections = yield* Effect.forEach(selectedCollectors, ({ collect }) => collect(selection), { concurrency: "unbounded" });
+    const fragments = mergeFragments(collections);
+    const holdbacks = normalizeReleaseAgeRecords(collections.flatMap((collection) => collection.holdbacks));
+    const bypasses = normalizeReleaseAgeRecords(collections.flatMap((collection) => collection.bypasses));
+    if (fragments.length === 0 && holdbacks.length === 0) {
+        return {
+            _tag: "NoConfiguredExtensions",
+            message: noConfiguredMessage(args.type),
+        };
+    }
+    const releaseAge = {
+        evaluatedAt: DateTime.formatIso(releaseAgeEvaluation.evaluatedAt),
+        holdbacks,
+        bypasses,
+    };
+    return {
+        _tag: "WorkspaceUpdatePlan",
+        plan: makeWorkspaceUpdatePlan(args.planName, args.planDescription, fragments.map((fragment) => fragment.step), args.type, releaseAge),
+    };
+});
+//# sourceMappingURL=configured.js.map

package/dist/src/update/root-request.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The grammar a root `update` request is written in.
+ *
+ * Root update names one extension by its Registry identity and nothing else.
+ * A path, URL, or Git source names a package whose identity the workspace
+ * cannot compare against what it already accepted, and a Library is a curated
+ * collection rather than an installed package, so both are refused here with
+ * the per-type route that does accept them. The refusal carries its own
+ * how-to-fix sentence: what a person should type instead depends on what they
+ * typed, and only this grammar knows that.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { ExtensionLifecycleFailed } from "../errors.js";
+import { type InstallableExtensionType } from "@agentxm/extension-model/unstable/extensions/installable-types";
+import { type ExtensionName, type Handle } from "@agentxm/extension-model/unstable/extensions";
+import type { VersionRange } from "@agentxm/extension-model/unstable/version-constraints";
+export declare const rootUpdatableTypeSegments: readonly ("knowledge" | "rules" | "hooks" | "mcps" | "skills" | "subagents" | "packs")[];
+export declare const RootUpdatableTypeSegmentSchema: Schema.Literals<readonly ("knowledge" | "rules" | "hooks" | "mcps" | "skills" | "subagents" | "packs")[]>;
+export type RootUpdatableTypeSegment = typeof RootUpdatableTypeSegmentSchema.Type;
+export type RootUpdatableType = InstallableExtensionType;
+/** One Registry identity a root update names, with the range it requested. */
+export interface RootUpdateIntent {
+    readonly source: string;
+    readonly type: RootUpdatableType;
+    readonly owner: Handle;
+    readonly name: ExtensionName;
+    readonly versionRange: Option.Option<VersionRange>;
+    readonly target: string;
+}
+/**
+ * Read one root-update request. Fails with the refusal a person can act on;
+ * succeeds with the Registry identity every later step is decided against.
+ */
+export declare const resolveRootUpdateIntent: (input: string) => Effect.Effect<RootUpdateIntent, ExtensionLifecycleFailed>;
+//# sourceMappingURL=root-request.d.ts.map