@agentxm/extension-lifecycle 0.28.7 → 0.28.9

package/dist/src/index.d.ts

@@ -13,6 +13,7 @@ export { ReleaseAgePosture, type ReleaseAgePostureValue } from "./release-age-po
 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";
+export { PUBLISHER_CHANGE_CONDITION_ID, classifyPublisherBindingTransition, publisherChangeRiskCondition, publisherTransitionWarning, registryBindingProposal, withPublisherTrust, withPublisherTrustConditions, type PublisherBindingTransition, } from "./publisher-binding.js";
 export { buildInstallCommandPlan, runInstallCommandWorkflow, type InstallExtensionCommandWorkflowActions, } from "./workflows/install-command/workflow.js";
 export { runUninstallCommandWorkflow, type UninstallExtensionCommandWorkflowActions, type UninstallWorkflowFlags, } from "./workflows/uninstall-command/workflow.js";
 export { materializeRegistryPackage, materializeRegistryPackageWithTreeIntegrity, type MaterializeRegistryPackageArgs, type RegistryPackageMaterializationMessages, } from "./registry-materialization.js";

package/dist/src/index.js

@@ -13,6 +13,7 @@ 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";
+export { PUBLISHER_CHANGE_CONDITION_ID, classifyPublisherBindingTransition, publisherChangeRiskCondition, publisherTransitionWarning, registryBindingProposal, withPublisherTrust, withPublisherTrustConditions, } from "./publisher-binding.js";
 export { buildInstallCommandPlan, runInstallCommandWorkflow, } from "./workflows/install-command/workflow.js";
 export { runUninstallCommandWorkflow, } from "./workflows/uninstall-command/workflow.js";
 export { materializeRegistryPackage, materializeRegistryPackageWithTreeIntegrity, } from "./registry-materialization.js";

package/dist/src/publisher-binding.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Publisher binding trust classification.
+ *
+ * A Registry resolution binds a publisher identity. When an operation
+ * proposes to replace an already accepted binding for the same configured
+ * extension with a different one, that transition is a trust decision a
+ * person makes at a prompt: no flag and no unattended mode can approve it.
+ * Every route that can replace an accepted binding — root and type update
+ * forms, reinstall and re-resolution, and pack closures — classifies the
+ * transition from the structured accepted and proposed identities here, so
+ * the same rule holds everywhere the transition can occur.
+ *
+ * A first acceptance is not a change, and an integrity mismatch while
+ * reacquiring the same accepted identity remains a hard failure elsewhere.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+import type * as Path from "effect/Path";
+import type { ExtensionRef } from "@agentxm/extension-model/unstable/extensions/refs/extension-ref";
+import type { ExtensionType } from "@agentxm/extension-model/unstable/extensions";
+import type { Plan, PlanRiskCondition, RegistryBindingProposal } from "@agentxm/workspace-operations";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+export interface PublisherBindingTransition {
+    readonly extensionType: ExtensionType;
+    /** The configured (local) name whose accepted resolution changes publisher. */
+    readonly target: string;
+    readonly owner: string;
+    readonly packageName: string;
+    /** The accepted publisher binding being replaced. */
+    readonly accepted: string;
+    /** The publisher binding the operation proposes to accept. */
+    readonly proposed: string;
+}
+export declare const PUBLISHER_CHANGE_CONDITION_ID = "publisher-ownership-change";
+/** The structured proposal an extension ref makes, when it is a Registry ref. */
+export declare const registryBindingProposal: (ref: ExtensionRef) => RegistryBindingProposal | undefined;
+/**
+ * Classify one proposed acceptance against the accepted resolution for the
+ * same configured target. Only a Registry binding replacing a different
+ * Registry binding is a publisher change.
+ */
+export declare const classifyPublisherBindingTransition: (args: {
+    readonly accepted: Option.Option<ExtensionRef>;
+    readonly proposed: RegistryBindingProposal;
+}) => Option.Option<PublisherBindingTransition>;
+/** The warning a step carries when its acceptance changes publisher. */
+export declare const publisherTransitionWarning: (transition: PublisherBindingTransition) => string;
+/**
+ * The interactive-only condition a plan carries when any of its steps
+ * replaces an accepted publisher binding.
+ */
+export declare const publisherChangeRiskCondition: (transitions: ReadonlyArray<PublisherBindingTransition>) => PlanRiskCondition | undefined;
+/** Append the publisher-change condition for the given transitions, if any. */
+export declare const withPublisherTrustConditions: <R, O>(plan: Plan<R, O>, transitions: ReadonlyArray<PublisherBindingTransition>) => Plan<R, O>;
+/**
+ * Classify every proposed Registry acceptance in a plan against the accepted
+ * resolutions of the workspace, marking each changing step and attaching the
+ * interactive-only condition. When an accepted resolution cannot be read the
+ * plan blocks rather than proceeding without the comparison.
+ */
+export declare const withPublisherTrust: <R, O>(plan: Plan<R, O>) => Effect.Effect<Plan<R, O>, never, WorkspaceMutations | FileSystem.FileSystem | Path.Path>;
+//# sourceMappingURL=publisher-binding.d.ts.map

package/dist/src/publisher-binding.js

@@ -0,0 +1,151 @@
+/**
+ * Publisher binding trust classification.
+ *
+ * A Registry resolution binds a publisher identity. When an operation
+ * proposes to replace an already accepted binding for the same configured
+ * extension with a different one, that transition is a trust decision a
+ * person makes at a prompt: no flag and no unattended mode can approve it.
+ * Every route that can replace an accepted binding — root and type update
+ * forms, reinstall and re-resolution, and pack closures — classifies the
+ * transition from the structured accepted and proposed identities here, so
+ * the same rule holds everywhere the transition can occur.
+ *
+ * A first acceptance is not a change, and an integrity mismatch while
+ * reacquiring the same accepted identity remains a hard failure elsewhere.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { toExtensionTypePlural } from "@agentxm/extension-model/unstable/extensions/common";
+import { acceptedResolutionRef, WorkspaceMutations } from "@agentxm/workspace-state";
+import { targetFromRef } from "@agentxm/extension-workspace";
+export const PUBLISHER_CHANGE_CONDITION_ID = "publisher-ownership-change";
+const ACCEPTED_RESOLUTION_UNREADABLE_ID = "accepted-resolution-unreadable";
+/** The structured proposal an extension ref makes, when it is a Registry ref. */
+export const registryBindingProposal = (ref) => ref.refType === "registry"
+    ? {
+        extensionType: ref.type,
+        target: targetFromRef(ref).name,
+        owner: ref.owner,
+        packageName: ref.name,
+        version: ref.version,
+        publisherBindingId: ref.publisherBindingId,
+    }
+    : undefined;
+/**
+ * Classify one proposed acceptance against the accepted resolution for the
+ * same configured target. Only a Registry binding replacing a different
+ * Registry binding is a publisher change.
+ */
+export const classifyPublisherBindingTransition = (args) => Option.flatMap(args.accepted, (accepted) => accepted.refType === "registry" &&
+    accepted.type === args.proposed.extensionType &&
+    accepted.publisherBindingId !== args.proposed.publisherBindingId
+    ? Option.some({
+        extensionType: args.proposed.extensionType,
+        target: args.proposed.target,
+        owner: args.proposed.owner,
+        packageName: args.proposed.packageName,
+        accepted: accepted.publisherBindingId,
+        proposed: args.proposed.publisherBindingId,
+    })
+    : Option.none());
+const describeTransition = (transition) => `${transition.owner}/${toExtensionTypePlural(transition.extensionType)}/${transition.packageName}`;
+/** The warning a step carries when its acceptance changes publisher. */
+export const publisherTransitionWarning = (transition) => `Publisher identity changed (${transition.accepted} → ${transition.proposed}); confirm only if you trust the current publisher`;
+/**
+ * The interactive-only condition a plan carries when any of its steps
+ * replaces an accepted publisher binding.
+ */
+export const publisherChangeRiskCondition = (transitions) => transitions.length === 0
+    ? undefined
+    : {
+        level: "confirmable",
+        consent: "interactive-only",
+        id: PUBLISHER_CHANGE_CONDITION_ID,
+        detail: `Publisher identity changed for ${transitions
+            .map(describeTransition)
+            .join(", ")}; confirm only if you trust the current publisher.`,
+    };
+/** Append the publisher-change condition for the given transitions, if any. */
+export const withPublisherTrustConditions = (plan, transitions) => {
+    const condition = publisherChangeRiskCondition(transitions);
+    return condition === undefined
+        ? plan
+        : { ...plan, riskConditions: [...(plan.riskConditions ?? []), condition] };
+};
+const stepWithTransitionWarning = (step, transition) => {
+    const warning = publisherTransitionWarning(transition);
+    switch (step.readiness) {
+        case "ready": {
+            const { message: _message, ...rest } = step;
+            return { ...rest, readiness: "warn", warnMessage: warning };
+        }
+        case "warn":
+            return { ...step, warnMessage: `${step.warnMessage}; ${warning}` };
+        case "error":
+            return step;
+    }
+};
+/**
+ * Classify every proposed Registry acceptance in a plan against the accepted
+ * resolutions of the workspace, marking each changing step and attaching the
+ * interactive-only condition. When an accepted resolution cannot be read the
+ * plan blocks rather than proceeding without the comparison.
+ */
+export const withPublisherTrust = (plan) => Effect.gen(function* () {
+    const workspace = yield* WorkspaceMutations;
+    const proposals = plan.jobs.flatMap((job) => job.steps.flatMap((step) => (step.registryBinding === undefined ? [] : [step])));
+    if (proposals.length === 0)
+        return plan;
+    const unreadable = [];
+    const transitionsByKey = new Map();
+    for (const step of proposals) {
+        const proposed = step.registryBinding;
+        if (proposed === undefined)
+            continue;
+        const accepted = yield* acceptedResolutionRef({
+            workspace,
+            type: proposed.extensionType,
+            name: proposed.target,
+        }).pipe(Effect.option);
+        if (Option.isNone(accepted)) {
+            unreadable.push(`${proposed.extensionType}:${proposed.target}`);
+            continue;
+        }
+        const transition = classifyPublisherBindingTransition({
+            accepted: accepted.value,
+            proposed,
+        });
+        if (Option.isSome(transition)) {
+            transitionsByKey.set(`${proposed.extensionType}:${proposed.target}`, transition.value);
+        }
+    }
+    const transitions = [...transitionsByKey.values()];
+    const marked = {
+        ...plan,
+        jobs: plan.jobs.map((job) => ({
+            ...job,
+            steps: job.steps.map((step) => {
+                const binding = step.registryBinding;
+                const transition = binding === undefined
+                    ? undefined
+                    : transitionsByKey.get(`${binding.extensionType}:${binding.target}`);
+                return transition === undefined ? step : stepWithTransitionWarning(step, transition);
+            }),
+        })),
+    };
+    const blocked = unreadable.length === 0
+        ? undefined
+        : {
+            level: "blocked",
+            id: ACCEPTED_RESOLUTION_UNREADABLE_ID,
+            detail: `The accepted resolution for ${unreadable.join(", ")} could not be read, so the proposed publisher binding cannot be checked.`,
+            errorCode: "conflict",
+        };
+    const withTrust = withPublisherTrustConditions(marked, transitions);
+    return blocked === undefined
+        ? withTrust
+        : { ...withTrust, riskConditions: [...(withTrust.riskConditions ?? []), blocked] };
+});
+//# sourceMappingURL=publisher-binding.js.map

package/dist/src/skills/operations/enable.js

@@ -55,7 +55,13 @@ export const enableSkill = (op) => Effect.gen(function* () {
     }
     const sanitizedName = sanitizeName(op.args.skillName);
     const materializationAgents = yield* DefaultCodingAgentRepository.getMaterializationAgents().pipe(Effect.provideService(WorkspaceMutations, ws));
-    const skillSrcPath = canonical.value.observation.path;
+    const accepted = canonical.value.accepted;
+    const portable = accepted !== undefined &&
+        "packageFormat" in accepted &&
+        accepted.packageFormat === "agent-skill";
+    const skillSrcPath = portable
+        ? canonical.value.observation.path
+        : path.join(canonical.value.observation.path, "src");
     const installableTargets = yield* ws.runTransaction({
         transition: Effect.gen(function* () {
             const resolvedTargets = yield* Effect.forEach(materializationAgents, (agent) => agent.resolveEffectiveSkillsDir({ workspaceRoot: base }).pipe(Effect.provide(fsPathLayer), Effect.map((outcome) => ({ agent, outcome }))), { concurrency: "unbounded" });

package/dist/src/workflows/install-command/workflow.d.ts

@@ -41,7 +41,7 @@ export interface InstallExtensionCommandWorkflowActions<Args, Parsed, Req, Ref,
 export declare const buildInstallCommandPlan: <Args, Parsed, Req, Ref, Intent, ParseError, ResolveError, TransformError = never, TransformRequirements = never>(args: Args, actions: InstallExtensionCommandWorkflowActions<Args, Parsed, Req, Ref, Intent, ParseError, ResolveError>, options?: {
     readonly transformIntent?: (intent: Intent) => Intent;
     readonly transformPlan?: (plan: Plan) => Effect.Effect<Plan, TransformError, TransformRequirements>;
-}) => Effect.Effect<Plan<never, never>, ParseError | ResolveError | TransformError, Scope.Scope | TransformRequirements>;
+}) => Effect.Effect<Plan<never, never>, ParseError | ResolveError | TransformError, import("@agentxm/workspace-state").WorkspaceMutations | import("effect/FileSystem").FileSystem | import("effect/Path").Path | Scope.Scope | TransformRequirements>;
 /**
  * Run the canonical install command workflow.
  *

package/dist/src/workflows/install-command/workflow.js

@@ -8,6 +8,7 @@
  */
 import * as Effect from "effect/Effect";
 import { observeUnit, previewOrApplyPlan, publishPhaseStarted, } from "@agentxm/workspace-operations";
+import { withPublisherTrust } from "../../publisher-binding.js";
 // -----------------------------------------------------------------------------
 // Install Command Workflow
 // -----------------------------------------------------------------------------
@@ -26,7 +27,11 @@ export const buildInstallCommandPlan = (args, actions, options) => Effect.gen(fu
     const finalizedIntent = yield* actions.finalizeIntent(parsed, refs);
     const intent = options?.transformIntent?.(finalizedIntent) ?? finalizedIntent;
     const plan = yield* actions.buildPlan(intent);
-    return options?.transformPlan === undefined ? plan : yield* options.transformPlan(plan);
+    const transformed = options?.transformPlan === undefined ? plan : yield* options.transformPlan(plan);
+    // Every acceptance the plan proposes is classified against the accepted
+    // resolution here, so root, type, reinstall, and closure routes share one
+    // publisher-trust rule.
+    return yield* withPublisherTrust(transformed);
 });
 /**
  * Run the canonical install command workflow.

package/package.json

@@ -1,64 +1,65 @@
 {
-  "name": "@agentxm/extension-lifecycle",
-  "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",
-  "homepage": "https://axm.sh",
+  "author": "AgentXM <hello@agentxm.ai> (https://agentxm.ai)",
   "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/extension-lifecycle"
+  "dependencies": {
+    "@agentxm/extension-model": "^0.28.9",
+    "@agentxm/extension-sources": "^0.28.9",
+    "@agentxm/extension-workspace": "^0.28.9",
+    "@agentxm/registry-client": "^0.28.9",
+    "@agentxm/registry-protocol": "^0.28.9",
+    "@agentxm/workspace-operations": "^0.28.9",
+    "@agentxm/workspace-state": "^0.28.9",
+    "@napi-rs/keyring": "^1.3.0",
+    "effect": "4.0.0-rc.112",
+    "semver": "^7.8.5"
+  },
+  "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.",
+  "devDependencies": {
+    "@effect/platform-node": "4.0.0-rc.112",
+    "@effect/vitest": "4.0.0-rc.112",
+    "@types/bun": "^1.3.14",
+    "@types/semver": "^7.7.1",
+    "@typescript/native": "npm:typescript@^7.0.2",
+    "typescript": "npm:@typescript/typescript6@^6.0.2",
+    "vitest": "^4.1.10",
+    "yaml": "^2.9.0"
+  },
+  "engines": {
+    "node": ">=22.19.0"
   },
-  "sideEffects": false,
   "exports": {
     ".": {
-      "types": "./dist/src/index.d.ts",
       "axm-source": "./src/index.ts",
-      "default": "./dist/src/index.js"
+      "default": "./dist/src/index.js",
+      "types": "./dist/src/index.d.ts"
     },
     "./live": {
-      "types": "./dist/src/live.d.ts",
       "axm-source": "./src/live.ts",
-      "default": "./dist/src/live.js"
+      "default": "./dist/src/live.js",
+      "types": "./dist/src/live.d.ts"
     }
   },
   "files": [
     "dist/src/",
     "!**/*.map"
   ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "engines": {
-    "node": ">=22.19.0"
-  },
+  "homepage": "https://axm.sh",
+  "license": "FSL-1.1-MIT",
+  "name": "@agentxm/extension-lifecycle",
   "nx": {
     "includedScripts": []
   },
-  "dependencies": {
-    "effect": "4.0.0-rc.112",
-    "semver": "^7.8.5",
-    "@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"
+  "publishConfig": {
+    "access": "public"
   },
-  "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",
-    "yaml": "^2.9.0"
-  }
-}
+  "repository": {
+    "directory": "packages/extension-lifecycle",
+    "type": "git",
+    "url": "https://github.com/agentxm/axm.git"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "version": "0.28.9"
+}