@agentxm/extension-lifecycle 0.28.12 → 0.28.13

package/dist/src/uninstall/root-intent.js

@@ -0,0 +1,101 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { installRefused } from "../install/vocabulary.js";
+import { installableExtensionTypePluralSegments, isInstallableExtensionTypePlural, toInstallableExtensionType, } from "@agentxm/extension-model/unstable/extensions/installable-types";
+import { RegistrySourceRefSchema } from "@agentxm/extension-model/unstable/extensions";
+import { parseInputPattern } from "@agentxm/extension-model/unstable/sources/parser";
+const decodeRegistrySourceRef = Schema.decodeUnknownEffect(RegistrySourceRefSchema);
+export const rootUninstallableTypeSegments = installableExtensionTypePluralSegments;
+const rootUninstallFqnGrammar = "@<handle>/<plural-type>/<name>[@<version>]";
+const supportedRootUninstallTypes = rootUninstallableTypeSegments.join(", ");
+const genericPerTypeUninstallGuidance = "Use the matching per-type uninstall command instead: `axm skills uninstall <name>`, `axm subagents uninstall <name>`, `axm packs uninstall <name>`, or `axm mcps uninstall <name>`.";
+const rootUninstallRegistryOnlyHowToFix = (source) => {
+    const parsed = parseInputPattern(source);
+    if (Option.isNone(parsed)) {
+        return `Use \`axm uninstall ${rootUninstallFqnGrammar}\`. ${genericPerTypeUninstallGuidance}`;
+    }
+    switch (parsed.value.pattern.pattern) {
+        case "name-input":
+        case "glob-input":
+            return `Root uninstall only accepts registry FQNs. Use the matching per-type command instead: \`axm skills uninstall ${source}\`, \`axm subagents uninstall ${source}\`, \`axm packs uninstall ${source}\`, or \`axm mcps uninstall ${source}\`.`;
+        case "file-path-pattern":
+        case "url-input":
+        case "git-scp-address":
+        case "shorthand-input":
+        case "slash-pattern":
+        case "registry-pattern-input":
+            return `Use \`axm uninstall ${rootUninstallFqnGrammar}\`. ${genericPerTypeUninstallGuidance}`;
+        case "workspace-pattern-input":
+            return "Use the matching per-type uninstall command for a workspace-authored extension.";
+    }
+};
+/**
+ * Root uninstall accepts only a registry FQN: it is the one form that names
+ * the extension type without guessing, and every other spelling has a
+ * per-type command that already knows the type.
+ */
+export const resolveRootUninstallIntent = Effect.fn("UninstallExtensions.resolveRootIntent")(function* (input) {
+    const source = input.trim();
+    const segments = source.split("/");
+    const pluralType = segments.length === 3 ? segments[1] : undefined;
+    if (!source.startsWith("@")) {
+        return yield* installRefused({
+            category: "usage",
+            detail: "Root uninstall only accepts registry FQNs",
+            suggestions: [{ description: rootUninstallRegistryOnlyHowToFix(source) }],
+        });
+    }
+    if (pluralType === "libraries") {
+        return yield* installRefused({
+            category: "usage",
+            detail: "Libraries are curated registry collections and cannot be uninstalled",
+            suggestions: [
+                {
+                    description: "Uninstall individual extensions by FQN; Libraries do not create workspace state.",
+                },
+            ],
+        });
+    }
+    const parsed = yield* decodeRegistrySourceRef(source).pipe(Effect.mapError((error) => {
+        if (pluralType !== undefined && !isInstallableExtensionTypePlural(pluralType)) {
+            return installRefused({
+                category: "not_found",
+                detail: "Uninstall source uses an unsupported plural type",
+                suggestions: [
+                    {
+                        description: `Use ${rootUninstallFqnGrammar}. Supported plural types: ${supportedRootUninstallTypes}.`,
+                    },
+                ],
+                cause: error,
+            });
+        }
+        return installRefused({
+            category: "validation",
+            detail: "Uninstall source must be a registry FQN",
+            suggestions: [
+                {
+                    description: `Use ${rootUninstallFqnGrammar} with one of: ${supportedRootUninstallTypes}.`,
+                },
+            ],
+            cause: error,
+        });
+    }));
+    if (!isInstallableExtensionTypePlural(parsed.type)) {
+        return yield* installRefused({
+            category: "usage",
+            detail: "Root uninstall does not support that extension type",
+            suggestions: [
+                {
+                    description: `Use ${rootUninstallFqnGrammar}. Supported plural types: ${supportedRootUninstallTypes}.`,
+                },
+            ],
+        });
+    }
+    return {
+        source,
+        type: toInstallableExtensionType(parsed.type),
+        name: parsed.name,
+    };
+});
+//# sourceMappingURL=root-intent.js.map

package/dist/src/uninstall/uninstall-extensions.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Uninstalling extensions.
+ *
+ * One use case behind eight command spellings. `axm uninstall @owner/type/name`
+ * reads the type from the FQN; `axm <type> uninstall <selector>` already knows
+ * it. From there the decision is the same: which installed extensions the
+ * selector names, whether each still has anything to withdraw, and what a
+ * removal is allowed to delete.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import type { InstallableExtensionType } from "@agentxm/extension-model/unstable/extensions/installable-types";
+import { type ExecutionCandidate, type OperationResolution, type PlanExecution } from "@agentxm/workspace-operations";
+import type { ExtensionLifecycleFailed } from "../errors.js";
+import { type PackUninstallRequirements } from "../packs/uninstall/plan.js";
+import type { InstallExecutionFailure, PrepareInstallRequirements } from "../install/vocabulary.js";
+/** One uninstall request, whatever command spelling produced it. */
+export interface UninstallExtensionsRequest {
+    /**
+     * The type the command fixed. `none` is the root form, which accepts only a
+     * registry FQN because that is the one spelling that names its own type.
+     */
+    readonly type: Option.Option<InstallableExtensionType>;
+    /** A name, a glob, or a registry FQN, as the person typed it. */
+    readonly selector: string;
+}
+/**
+ * A settled removal: every target is resolved and nothing is written. `type`
+ * is the type the removal settled on, which the root form derived from the
+ * FQN; `names` are the extensions it will withdraw.
+ */
+export interface UninstallExtensionsCandidate {
+    readonly type: InstallableExtensionType;
+    /**
+     * The selector scoped to the settled type: what a typed route was given,
+     * and the extension name the root form read out of the registry FQN. What
+     * a report names the subject with, whether or not anything matched.
+     */
+    readonly selector: string;
+    readonly names: ReadonlyArray<string>;
+    /** The selector matched nothing installed; the application renders a no-op. */
+    readonly empty: boolean;
+    readonly planName: string;
+    readonly execution: ExecutionCandidate<PackUninstallRequirements>;
+}
+/** Every failure settling a removal can surface before anything is written. */
+export type UninstallExtensionsFailure = ExtensionLifecycleFailed | InstallExecutionFailure;
+/** Everything settling a removal reads before it freezes a candidate. */
+export type PrepareUninstallRequirements = PrepareInstallRequirements | PackUninstallRequirements;
+/** Settle a removal without writing anything. */
+export declare const prepareUninstallExtensions: (request: UninstallExtensionsRequest) => Effect.Effect<UninstallExtensionsCandidate, UninstallExtensionsFailure, PrepareUninstallRequirements>;
+/** Preview or apply a settled removal, resolving to one operation outcome. */
+export declare const previewOrApplyUninstallExtensions: (candidate: UninstallExtensionsCandidate, execution: PlanExecution) => Effect.Effect<OperationResolution, UninstallExtensionsFailure, PrepareUninstallRequirements>;
+/** The removal use case: settle a request, then preview or apply it. */
+export declare const UninstallExtensions: {
+    readonly prepare: (request: UninstallExtensionsRequest) => Effect.Effect<UninstallExtensionsCandidate, UninstallExtensionsFailure, PrepareUninstallRequirements>;
+    readonly previewOrApply: (candidate: UninstallExtensionsCandidate, execution: PlanExecution) => Effect.Effect<OperationResolution, UninstallExtensionsFailure, PrepareUninstallRequirements>;
+};
+//# sourceMappingURL=uninstall-extensions.d.ts.map

package/dist/src/uninstall/uninstall-extensions.js

@@ -0,0 +1,127 @@
+/**
+ * Uninstalling extensions.
+ *
+ * One use case behind eight command spellings. `axm uninstall @owner/type/name`
+ * reads the type from the FQN; `axm <type> uninstall <selector>` already knows
+ * it. From there the decision is the same: which installed extensions the
+ * selector names, whether each still has anything to withdraw, and what a
+ * removal is allowed to delete.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { operationPresentation, prepareExecutionCandidate, resolveExecutionCandidate, } from "@agentxm/workspace-operations";
+import { parseHookUninstallRequest, planHookUninstall } from "../hooks/uninstall/plan.js";
+import { parseKnowledgeUninstallRequest, planKnowledgeUninstall, } from "../knowledge/uninstall/plan.js";
+import { parseMcpServerUninstallRequest, planMcpServerUninstall } from "../mcps/uninstall/plan.js";
+import { finalizePackUninstallIntent, parsePackUninstallSelectors, planPackUninstall, } from "../packs/uninstall/plan.js";
+import { parseRuleUninstallRequest, planRuleUninstall } from "../rules/uninstall/plan.js";
+import { parseSkillUninstallRequest, planSkillUninstall } from "../skills/uninstall/plan.js";
+import { parseSubagentUninstallRequest, planSubagentUninstall, } from "../subagents/uninstall/plan.js";
+import { resolveRootUninstallIntent } from "./root-intent.js";
+const planForType = (type, selector) => {
+    switch (type) {
+        case "skill":
+            return Effect.gen(function* () {
+                const intent = yield* parseSkillUninstallRequest(selector);
+                return {
+                    names: intent.targets.map((target) => target.name),
+                    plan: yield* planSkillUninstall(intent),
+                };
+            });
+        case "subagent":
+            return Effect.gen(function* () {
+                const intent = yield* parseSubagentUninstallRequest(selector);
+                return {
+                    names: intent.targets.map((target) => target.name),
+                    plan: yield* planSubagentUninstall(intent),
+                };
+            });
+        case "mcp-server":
+            return Effect.gen(function* () {
+                const intent = parseMcpServerUninstallRequest(selector);
+                return {
+                    names: intent.targets.map((target) => target.name),
+                    plan: yield* planMcpServerUninstall(intent),
+                };
+            });
+        case "rule":
+            return Effect.gen(function* () {
+                const intent = yield* parseRuleUninstallRequest(selector);
+                return {
+                    names: intent.targets.map((target) => target.name),
+                    plan: yield* planRuleUninstall(intent),
+                };
+            });
+        case "hook":
+            return Effect.gen(function* () {
+                const intent = yield* parseHookUninstallRequest(selector);
+                return {
+                    names: intent.targets.map((target) => target.name),
+                    plan: yield* planHookUninstall(intent),
+                };
+            });
+        case "knowledge":
+            return Effect.gen(function* () {
+                const intent = yield* parseKnowledgeUninstallRequest(selector);
+                return {
+                    names: intent.targets.map((target) => target.name),
+                    plan: yield* planKnowledgeUninstall(intent),
+                };
+            });
+        case "pack":
+            return Effect.gen(function* () {
+                const selectors = yield* parsePackUninstallSelectors(selector);
+                const intent = yield* finalizePackUninstallIntent(selectors);
+                return {
+                    names: intent.packsToUninstall.map((pack) => pack.name),
+                    plan: yield* planPackUninstall(intent),
+                };
+            });
+    }
+};
+// -----------------------------------------------------------------------------
+// prepare
+// -----------------------------------------------------------------------------
+/** Settle a removal without writing anything. */
+export const prepareUninstallExtensions = Effect.fn("UninstallExtensions.prepare")(function* (request) {
+    const resolved = yield* Option.match(request.type, {
+        onSome: (type) => Effect.succeed({ type, selector: request.selector }),
+        onNone: () => resolveRootUninstallIntent(request.selector).pipe(Effect.map((intent) => ({ type: intent.type, selector: intent.name }))),
+    });
+    const planned = yield* planForType(resolved.type, resolved.selector);
+    // The plan's own name stands whichever spelling produced it: the removal a
+    // person asked for is type-specific, and the plan name is what they read.
+    // Only the presented subject varies — the root form routes across every
+    // type, so it presents the default subject rather than the one this
+    // request happened to settle on.
+    const plan = {
+        ...planned.plan,
+        presentation: operationPresentation({ imperative: "uninstall", past: "Uninstalled", gerund: "Uninstalling" }, Option.getOrUndefined(request.type)),
+    };
+    // Every removal withdraws the extension's per-agent projection, so the
+    // candidate carries the configured-agent operation the resolution projects
+    // before the removal and verifies after it.
+    const configuredAgentOperations = planned.names.map((name) => ({ extensionType: resolved.type, name, plannedState: "absent" }));
+    const execution = yield* prepareExecutionCandidate(plan, { configuredAgentOperations });
+    return {
+        type: resolved.type,
+        selector: resolved.selector,
+        names: planned.names,
+        empty: planned.names.length === 0,
+        planName: plan.name,
+        execution,
+    };
+});
+// -----------------------------------------------------------------------------
+// previewOrApply
+// -----------------------------------------------------------------------------
+/** Preview or apply a settled removal, resolving to one operation outcome. */
+export const previewOrApplyUninstallExtensions = (candidate, execution) => resolveExecutionCandidate(candidate.execution, execution);
+/** The removal use case: settle a request, then preview or apply it. */
+export const UninstallExtensions = {
+    prepare: prepareUninstallExtensions,
+    previewOrApply: previewOrApplyUninstallExtensions,
+};
+//# sourceMappingURL=uninstall-extensions.js.map

package/dist/src/uninstall/vocabulary.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The vocabulary every uninstall route shares.
+ *
+ * Root uninstall and the seven per-type uninstalls are one use case with the
+ * type either fixed by the command or read from the registry FQN, so they
+ * share one settled target list and one disposition vocabulary. What a
+ * removal actually did — removed the package, retained it for a pack, left
+ * unowned content in place, or found nothing at all — is reported as a typed
+ * settlement rather than inferred from a sentence.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import type { HookExtensionTarget, KnowledgeExtensionTarget, McpServerExtensionTarget, PackExtensionTarget, RuleExtensionTarget, SkillExtensionTarget, SubagentExtensionTarget } from "@agentxm/workspace-state";
+/** One skill removal. */
+export interface SkillUninstallIntent {
+    readonly targets: ReadonlyArray<SkillExtensionTarget>;
+}
+/** One subagent removal. */
+export interface SubagentUninstallIntent {
+    readonly targets: ReadonlyArray<SubagentExtensionTarget>;
+}
+/** One MCP connection removal. */
+export interface McpServerUninstallIntent {
+    readonly targets: ReadonlyArray<McpServerExtensionTarget>;
+}
+/** One rule removal. */
+export interface RuleUninstallIntent {
+    readonly targets: ReadonlyArray<RuleExtensionTarget>;
+}
+/** One hooks-package removal. */
+export interface HookUninstallIntent {
+    readonly targets: ReadonlyArray<HookExtensionTarget>;
+}
+/** One knowledge-bundle removal. */
+export interface KnowledgeUninstallIntent {
+    readonly targets: ReadonlyArray<KnowledgeExtensionTarget>;
+}
+/** One pack removal, with the owner and authority its desired identity named. */
+export type PackUninstallTarget = PackExtensionTarget;
+//# sourceMappingURL=vocabulary.d.ts.map

package/dist/src/uninstall/vocabulary.js

@@ -0,0 +1,14 @@
+/**
+ * The vocabulary every uninstall route shares.
+ *
+ * Root uninstall and the seven per-type uninstalls are one use case with the
+ * type either fixed by the command or read from the registry FQN, so they
+ * share one settled target list and one disposition vocabulary. What a
+ * removal actually did — removed the package, retained it for a pack, left
+ * unowned content in place, or found nothing at all — is reported as a typed
+ * settlement rather than inferred from a sentence.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export {};
+//# sourceMappingURL=vocabulary.js.map

package/dist/src/update/atomicity.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The atomicity a workspace-wide update declares, and why.
+ *
+ * A targeted update is one closure and keeps the ordinary closure-atomic
+ * promise. A workspace-wide sweep is not: it advances every configured entry
+ * that can advance, each as its own closure, and deliberately leaves the ones
+ * that already advanced committed when a later entry fails. There is no
+ * cross-closure undo, so the operation reports itself `non-rollbackable`
+ * rather than claiming a rollback it will not perform.
+ *
+ * The declaration lives with the update use case so the atomicity a person
+ * reads in the result document is the one its owner decided, not one a
+ * transport adapter chose while assembling a plan literal.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import type { AtomicityClass, PlanExecutionCapabilities } from "@agentxm/workspace-operations";
+/** A workspace-wide update settles each entry independently and undoes none. */
+export declare const WORKSPACE_UPDATE_ATOMICITY: AtomicityClass;
+/** The execution capabilities a workspace-wide update plan declares. */
+export declare const WORKSPACE_UPDATE_EXECUTION_CAPABILITIES: PlanExecutionCapabilities;
+//# sourceMappingURL=atomicity.d.ts.map

package/dist/src/update/atomicity.js

@@ -0,0 +1,23 @@
+/**
+ * The atomicity a workspace-wide update declares, and why.
+ *
+ * A targeted update is one closure and keeps the ordinary closure-atomic
+ * promise. A workspace-wide sweep is not: it advances every configured entry
+ * that can advance, each as its own closure, and deliberately leaves the ones
+ * that already advanced committed when a later entry fails. There is no
+ * cross-closure undo, so the operation reports itself `non-rollbackable`
+ * rather than claiming a rollback it will not perform.
+ *
+ * The declaration lives with the update use case so the atomicity a person
+ * reads in the result document is the one its owner decided, not one a
+ * transport adapter chose while assembling a plan literal.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+/** A workspace-wide update settles each entry independently and undoes none. */
+export const WORKSPACE_UPDATE_ATOMICITY = "non-rollbackable";
+/** The execution capabilities a workspace-wide update plan declares. */
+export const WORKSPACE_UPDATE_EXECUTION_CAPABILITIES = {
+    rollback: WORKSPACE_UPDATE_ATOMICITY,
+};
+//# sourceMappingURL=atomicity.js.map

package/dist/src/update/blockers.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Why a targeted update may not proceed, said once.
+ *
+ * Every reason a named update is refused is a fact about the workspace, not
+ * about the command that asked: the extension is not desired, the entry is
+ * turned off, a Pack owns the constraint the request would fork, the Pack
+ * graph cannot prove ownership, the declared constraints do not intersect,
+ * the source is the copy embedded in this executable, the source is
+ * workspace-authored, or the ownership context went stale under the
+ * transition. The sentence and the blocking class belong here so preview,
+ * apply, and machine output all report the same refusal.
+ *
+ * What a person should type next is the application's to render: the blocker
+ * travels as `blocking.reference`, and the adapter maps it to the command it
+ * knows how to spell.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import type { TargetedUpdateBlocker, TargetedUpdatePublicContext } from "@agentxm/extension-resolution";
+import type { BlockingClass } from "@agentxm/workspace-operations";
+/** The refusal sentence for one classified blocker. */
+export declare const blockerDetail: (context: TargetedUpdatePublicContext) => string;
+/**
+ * Which kind of blocking a refusal is: a policy the workspace chose to
+ * enforce, a precondition the workspace does not meet, or an answer that went
+ * out of date.
+ */
+export declare const blockerClass: (blocker: TargetedUpdateBlocker | undefined) => BlockingClass;
+/** The ownership context a stale outcome reports: nothing moved. */
+export declare const staleOutputContext: (context: TargetedUpdatePublicContext) => TargetedUpdatePublicContext;
+//# sourceMappingURL=blockers.d.ts.map

package/dist/src/update/blockers.js

@@ -0,0 +1,78 @@
+/**
+ * Why a targeted update may not proceed, said once.
+ *
+ * Every reason a named update is refused is a fact about the workspace, not
+ * about the command that asked: the extension is not desired, the entry is
+ * turned off, a Pack owns the constraint the request would fork, the Pack
+ * graph cannot prove ownership, the declared constraints do not intersect,
+ * the source is the copy embedded in this executable, the source is
+ * workspace-authored, or the ownership context went stale under the
+ * transition. The sentence and the blocking class belong here so preview,
+ * apply, and machine output all report the same refusal.
+ *
+ * What a person should type next is the application's to render: the blocker
+ * travels as `blocking.reference`, and the adapter maps it to the command it
+ * knows how to spell.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { TARGETED_UPDATE_STALE_DETAIL } from "./targeted-plan.js";
+/** The refusal sentence for one classified blocker. */
+export const blockerDetail = (context) => {
+    const withRelevantProblems = (detail) => context.relevantProblems.length === 0
+        ? detail
+        : `${detail}. ${context.relevantProblems.join("; ")}`;
+    if (context.blocker === undefined) {
+        return `Update ${context.target.fqn} is blocked`;
+    }
+    switch (context.blocker) {
+        case "not-desired":
+            return `${context.target.fqn} is not desired by this workspace`;
+        case "disabled":
+            return `${context.target.fqn} is effectively disabled`;
+        case "pack-owned-constraint":
+            return `${context.target.fqn} is pack-owned; a targeted version range would create direct intent`;
+        case "incomplete-graph":
+            return withRelevantProblems(`Pack membership is incomplete, so ownership of ${context.target.fqn} cannot be proven`);
+        case "constraint-conflict":
+            return withRelevantProblems(`The desired constraints for ${context.target.fqn} have no compatible intersection`);
+        case "bundled-source":
+            return `${context.target.fqn} uses the skill embedded in this AXM executable and cannot be advanced from the Registry`;
+        case "source-authority":
+            return `${context.target.fqn} is workspace-authored and cannot be replaced from the Registry`;
+        case "stale-plan":
+            return TARGETED_UPDATE_STALE_DETAIL;
+    }
+};
+/**
+ * Which kind of blocking a refusal is: a policy the workspace chose to
+ * enforce, a precondition the workspace does not meet, or an answer that went
+ * out of date.
+ */
+export const blockerClass = (blocker) => {
+    switch (blocker) {
+        case "pack-owned-constraint":
+        case "bundled-source":
+        case "source-authority":
+            return "policy-excluded";
+        case "stale-plan":
+            return "stale-candidate";
+        default:
+            return "precondition-unmet";
+    }
+};
+/** The ownership context a stale outcome reports: nothing moved. */
+export const staleOutputContext = (context) => ({
+    ...context,
+    authority: "blocked",
+    blocker: "stale-plan",
+    effects: {
+        settings: "unchanged",
+        acceptedResolution: "unchanged",
+        canonical: "unchanged",
+        projection: "unchanged",
+        packRoot: "unchanged",
+        packManifest: "unchanged",
+    },
+});
+//# sourceMappingURL=blockers.js.map

package/dist/src/update/configured.d.ts

@@ -0,0 +1,78 @@
+/**
+ * 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 Option from "effect/Option";
+import type * as FileSystem from "effect/FileSystem";
+import type * as Path from "effect/Path";
+import type * as Scope from "effect/Scope";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import { ReleaseAgePosture, resolveConfiguredSkill } from "@agentxm/extension-resolution";
+import { type Plan, type PlannedJobStep } from "@agentxm/workspace-operations";
+import { WorkspaceMutations, type WorkspaceSettingsReadFailure, type WorkspaceStateReadFailure } from "@agentxm/workspace-state";
+import { type InstallableExtensionType } from "@agentxm/extension-model/unstable/extensions/installable-types";
+import { HookManager, KnowledgeManager, McpServerManager, PackManager, RuleManager, SkillManager, SubagentManager } from "@agentxm/extension-materialization";
+import { SourceHostProviders, WorkspaceCatalog } from "@agentxm/extension-sources";
+import { ExtensionLifecycleFailed } from "../errors.js";
+import { StepFailureConversion } from "../step-failure-conversion.js";
+import type { InstallStepRequirements } from "../install/vocabulary.js";
+import { type PackInstallRequirements } from "../packs/install/plan.js";
+export type WorkspaceUpdatableType = InstallableExtensionType;
+/**
+ * Everything sweeping the configured entries can fail with before a plan
+ * exists: the feature's own refusals, whatever resolving one entry against
+ * its source surfaced, and the workspace reads the sweep performs.
+ */
+export type ConfiguredUpdateFailure = ExtensionLifecycleFailed | Effect.Error<ReturnType<typeof resolveConfiguredSkill>> | WorkspaceStateReadFailure | WorkspaceSettingsReadFailure;
+type WorkspaceUpdateCollectorContext = InstallStepRequirements | PackInstallRequirements | StepFailureConversion | Scope.Scope | HttpClient.HttpClient | FileSystem.FileSystem | Path.Path | WorkspaceMutations | WorkspaceCatalog | SourceHostProviders | HookManager | KnowledgeManager | McpServerManager | PackManager | RuleManager | SkillManager | SubagentManager;
+/**
+ * Name selector shared by every collector. `undefined` means "no selector was
+ * given" and is distinct from an empty set, which selects nothing.
+ */
+export interface WorkspaceUpdateNameSelection {
+    readonly names: ReadonlySet<string> | undefined;
+}
+export type WorkspaceUpdatePlanResult = {
+    readonly _tag: "NoConfiguredExtensions";
+    readonly message: string;
+} | {
+    readonly _tag: "WorkspaceUpdatePlan";
+    readonly plan: Plan<InstallStepRequirements>;
+};
+export declare const makeWorkspaceUpdatePlan: (name: string, description: Option.Option<string>, steps: ReadonlyArray<PlannedJobStep<InstallStepRequirements>>, type: Option.Option<WorkspaceUpdatableType>, releaseAge: Plan<InstallStepRequirements>["releaseAge"]) => Plan<InstallStepRequirements>;
+/** What a configured sweep asks for: a type filter and an optional selection. */
+export interface WorkspaceUpdatePlanRequest {
+    readonly type: Option.Option<WorkspaceUpdatableType>;
+    readonly planName: string;
+    readonly planDescription: Option.Option<string>;
+    /** Installed names the caller's selector resolved to; omit to update all. */
+    readonly names?: ReadonlyArray<string>;
+    /** Whether the invoking surface can prompt while the planned advance runs. */
+    readonly nonInteractive: boolean;
+}
+/**
+ * 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 declare const buildWorkspaceUpdatePlan: (request: WorkspaceUpdatePlanRequest) => Effect.Effect<WorkspaceUpdatePlanResult, ConfiguredUpdateFailure, WorkspaceUpdateCollectorContext | ReleaseAgePosture>;
+export {};
+//# sourceMappingURL=configured.d.ts.map