@agentxm/workspace-operations 0.28.7-preview.1788522540.63ba4b89a → 0.28.8

package/dist/src/index.d.ts

@@ -10,19 +10,19 @@
  * @experimental This API is unstable and may change without notice.
  * @packageDocumentation
  */
-export { BlockingClassSchema, defaultOperationPresentation, operationPresentation, presentationOf, ArtifactMechanismSchema, OperationPreconditionSchema, PlanPolicyIdSchema, PlanPolicyIds, PlanRiskConditionSchema, } from "./plan/plan.js";
-export type { ArtifactMechanism, BlockingClass, CompletedJobStep, ErrorJobStep, ExecutedJob, ExecutedPlan, Job, JobStepArtifact, JobStepArtifactSource, JobStepArtifactTarget, JobStepResult, Operation, OperationPrecondition, OperationPresentation, Plan, PlanPolicyId, PlanRiskCondition, PlannedJobStep, ReadyJobStep, RegistryLifecycleEvidence, UnitBlocking, WarnJobStep, } from "./plan/plan.js";
+export { BlockingClassSchema, defaultOperationPresentation, operationPresentation, presentationOf, ArtifactMechanismSchema, ConfirmableConsentSchema, OperationPreconditionSchema, PlanPolicyIdSchema, PlanPolicyIds, PlanRiskConditionSchema, } from "./plan/plan.js";
+export type { ArtifactMechanism, BlockingClass, CompletedJobStep, ConfirmableConsent, ErrorJobStep, ExecutedJob, ExecutedPlan, Job, JobStepArtifact, JobStepArtifactSource, JobStepArtifactTarget, JobStepResult, Operation, OperationPrecondition, OperationPresentation, Plan, PlanPolicyId, PlanRiskCondition, PlannedJobStep, ReadyJobStep, RegistryBindingProposal, RegistryLifecycleEvidence, UnitBlocking, WarnJobStep, } from "./plan/plan.js";
 export { AtomicityClassSchema, OperationOutcomeSchema, OperationPhaseSchema, UnitDispositionSchema, UnitStateSchema, countUnitStates, declaredAtomicity, deriveOperationOutcome, executedUnits, makeOperationResolution, plannedUnits, unitIdOf, unitsByStableIdentity, } from "./plan/operation-resolution.js";
 export type { AtomicityClass, MakeOperationResolutionArgs, OperationAtomicity, OperationBlock, OperationFootprintEntry, OperationInterruption, OperationOutcome, OperationPhase, OperationRecovery, OperationResolution, ResolvedUnit, UnitDisposition, UnitState, UnitStateCounts, } from "./plan/operation-resolution.js";
 export { OperationJournal, appendResolvedUnit, appendStartedUnit, recordJournalPhase, getOperationJournal, makeOperationJournal, recordOperationJournal, updateOperationJournal, type OperationJournalService, type OperationJournalState, } from "./plan/operation-journal.js";
 export { applyPlan, type ApplyPlanOptions, type OperationHandler } from "./plan/apply-plan.js";
-export { CurrentOperationUnit, OperationEventSchema, OperationLifecycle, OperationModeSchema, ProgressUnitSchema, SettledOutcomeSchema, awaitDrained, lifecycleEvents, makeOperationLifecycle, makeThrottledUnitProgress, observeUnit, publishOperationEvent, publishPhaseStarted, publishUnitProgress, publishWaitEnded, publishWaiting, settleOperation, subscribeLossless, type ObservedUnit, type OperationEvent, type OperationEventEncoded, type OperationEventInput, type OperationLifecycleService, type OperationMode, type ProgressUnit, type SettledOutcome, } from "./plan/operation-events.js";
+export { CurrentOperationUnit, OperationEventSchema, OperationLifecycle, OperationModeSchema, ProgressUnitSchema, SettledOutcomeSchema, awaitDrained, lifecycleEvents, makeOperationLifecycle, makeThrottledUnitProgress, observeChildUnit, observeUnit, publishOperationEvent, publishPhaseStarted, publishUnitProgress, publishWaitEnded, publishWaiting, settleOperation, subscribeLossless, type ObservedUnit, type OperationEvent, type OperationEventEncoded, type OperationEventInput, type OperationLifecycleService, type OperationMode, type ProgressUnit, type SettledOutcome, } from "./plan/operation-events.js";
 export { ApprovalRecoveryMissing, CandidateFingerprintFailed, OPERATION_ERROR_CATEGORIES, OperationErrorCategorySchema, PlanInteractionFailed, STALE_CANDIDATE_DETAIL, StaleExecutionCandidate, StepFailure, type OperationErrorCategory, } from "./plan/errors.js";
 export { previewOrApplyPlan } from "./plan/resolve-plan.js";
 export { ResolvePlanInteraction, type ApplyConfirmation, type ResolvePlanInteractionService, } from "./plan/resolve-plan-interaction.js";
 export { InterruptionSignalSource, type InterruptionSignalSourceService, } from "./plan/interruption-signal.js";
 export { isExecutionCandidateFresh, makeExecutionCandidate, type ExecutionCandidate, } from "./plan/execution-candidate.js";
-export { applyPlanExecution, confirmationRecoverySuggestions, namedPolicyRecoverySuggestions, credentialFreeLocatorRecoveryValue, preapprovedPlanExecution, promptablePlanExecution, previewPlanExecution, protectedRecoveryValue, publicRecoveryValue, recoveryOption, recoveryPositional, recoverySwitch, renderConfirmationRecoveryCommand, unclassifiedRecoveryValue, type ConfirmationRecovery, type ConfirmationRecoveryArgument, type ConfirmationRecoveryValue, type ConfiguredAgentOperation, type PlanExecution, type PlanExecutionRequest, } from "./plan/plan-execution.js";
+export { applyPlanExecution, confirmationRecoverySuggestions, namedPolicyRecoverySuggestions, credentialFreeLocatorRecoveryValue, previewPlanExecution, protectedRecoveryValue, publicRecoveryValue, recoveryOption, recoveryPositional, recoverySwitch, renderConfirmationRecoveryCommand, unclassifiedRecoveryValue, type ConfirmableRiskApproval, type ConfirmationRecovery, type ConfirmationRecoveryArgument, type ConfirmationRecoveryValue, type ConfiguredAgentOperation, type PlanExecution, type PlanExecutionRequest, type RecoveryApproval, } from "./plan/plan-execution.js";
 export * from "./plan/job-step-message.js";
 export { scanPlanReadiness, type PlanReadinessReport } from "./operations/scan-plan-readiness.js";
 export { augmentPlanWithReconciliation, type AugmentedPlanResult, type DegradedLockfileState, } from "./operations/augment-plan.js";

package/dist/src/index.js

@@ -11,7 +11,7 @@
  * @packageDocumentation
  */
 // Plan types
-export { BlockingClassSchema, defaultOperationPresentation, operationPresentation, presentationOf, ArtifactMechanismSchema, OperationPreconditionSchema, PlanPolicyIdSchema, PlanPolicyIds, PlanRiskConditionSchema, } from "./plan/plan.js";
+export { BlockingClassSchema, defaultOperationPresentation, operationPresentation, presentationOf, ArtifactMechanismSchema, ConfirmableConsentSchema, OperationPreconditionSchema, PlanPolicyIdSchema, PlanPolicyIds, PlanRiskConditionSchema, } from "./plan/plan.js";
 // Operation resolution — the single value every plan-family command
 // terminates with, with its pure outcome derivations.
 export { AtomicityClassSchema, OperationOutcomeSchema, OperationPhaseSchema, UnitDispositionSchema, UnitStateSchema, countUnitStates, declaredAtomicity, deriveOperationOutcome, executedUnits, makeOperationResolution, plannedUnits, unitIdOf, unitsByStableIdentity, } from "./plan/operation-resolution.js";
@@ -20,7 +20,7 @@ export { OperationJournal, appendResolvedUnit, appendStartedUnit, recordJournalP
 // Apply plan + operation handler registry
 export { applyPlan } from "./plan/apply-plan.js";
 // Operation lifecycle events — the live contract every observer subscribes to.
-export { CurrentOperationUnit, OperationEventSchema, OperationLifecycle, OperationModeSchema, ProgressUnitSchema, SettledOutcomeSchema, awaitDrained, lifecycleEvents, makeOperationLifecycle, makeThrottledUnitProgress, observeUnit, publishOperationEvent, publishPhaseStarted, publishUnitProgress, publishWaitEnded, publishWaiting, settleOperation, subscribeLossless, } from "./plan/operation-events.js";
+export { CurrentOperationUnit, OperationEventSchema, OperationLifecycle, OperationModeSchema, ProgressUnitSchema, SettledOutcomeSchema, awaitDrained, lifecycleEvents, makeOperationLifecycle, makeThrottledUnitProgress, observeChildUnit, observeUnit, publishOperationEvent, publishPhaseStarted, publishUnitProgress, publishWaitEnded, publishWaiting, settleOperation, subscribeLossless, } from "./plan/operation-events.js";
 // Serialized error vocabulary and the plan-family tagged errors.
 export { ApprovalRecoveryMissing, CandidateFingerprintFailed, OPERATION_ERROR_CATEGORIES, OperationErrorCategorySchema, PlanInteractionFailed, STALE_CANDIDATE_DETAIL, StaleExecutionCandidate, StepFailure, } from "./plan/errors.js";
 // Interactive preview/apply orchestration over the workspace read model.
@@ -30,7 +30,7 @@ export { previewOrApplyPlan } from "./plan/resolve-plan.js";
 export { ResolvePlanInteraction, } from "./plan/resolve-plan-interaction.js";
 export { InterruptionSignalSource, } from "./plan/interruption-signal.js";
 export { isExecutionCandidateFresh, makeExecutionCandidate, } from "./plan/execution-candidate.js";
-export { applyPlanExecution, confirmationRecoverySuggestions, namedPolicyRecoverySuggestions, credentialFreeLocatorRecoveryValue, preapprovedPlanExecution, promptablePlanExecution, previewPlanExecution, protectedRecoveryValue, publicRecoveryValue, recoveryOption, recoveryPositional, recoverySwitch, renderConfirmationRecoveryCommand, unclassifiedRecoveryValue, } from "./plan/plan-execution.js";
+export { applyPlanExecution, confirmationRecoverySuggestions, namedPolicyRecoverySuggestions, credentialFreeLocatorRecoveryValue, previewPlanExecution, protectedRecoveryValue, publicRecoveryValue, recoveryOption, recoveryPositional, recoverySwitch, renderConfirmationRecoveryCommand, unclassifiedRecoveryValue, } from "./plan/plan-execution.js";
 // Job step messaging
 export * from "./plan/job-step-message.js";
 // Plan readiness and reconciliation gating

package/dist/src/plan/operation-events.d.ts

@@ -233,21 +233,37 @@ export declare const makeThrottledUnitProgress: (options: {
     readonly unit: ProgressUnit;
     readonly intervalMs?: number | undefined;
 }) => Effect.Effect<(done: number, total?: number | undefined) => Effect.Effect<void>>;
-export interface ObservedUnit {
+export interface ObservedUnit<A = never> {
     readonly id: string;
     readonly label: string;
     /** Planned position; assigned by the service when the caller has none. */
     readonly index?: number | undefined;
     readonly total?: number | undefined;
     readonly parentUnitId?: string | undefined;
+    /**
+     * The label the unit settles with, read from the value it produced. A unit
+     * that exists to resolve a fact reports that fact here, so its settlement
+     * names the answer instead of repeating the question. Only a successful
+     * exit has a value to read; a failed or interrupted unit settles with the
+     * label it started with.
+     */
+    readonly resolvedLabel?: (value: A) => string;
 }
 /**
  * Run one unit of work under the lifecycle: `UnitStarted` before, then
  * `UnitResolved` with the state the exit proves (`committed`, `failed`, or
- * `interrupted`). The unit identity is provided to the run so nested producers
- * can publish progress. No-op wrapper without a broadcast.
+ * `interrupted`) and the label the unit settles with. The unit identity is
+ * provided to the run so nested producers can publish progress. No-op wrapper
+ * without a broadcast.
+ */
+export declare const observeUnit: <A, E, R>(unit: ObservedUnit<A>, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * Run a unit as a child of the unit currently in progress, so work a step
+ * delegates nests under the step that delegated it. Identical to
+ * `observeUnit` when no unit is in progress, and when the caller states its
+ * own parent that statement wins.
  */
-export declare const observeUnit: <A, E, R>(unit: ObservedUnit, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+export declare const observeChildUnit: <A, E, R>(unit: ObservedUnit<A>, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
 /** Publish the terminal event once. No-op without a broadcast. */
 export declare const settleOperation: (outcome: SettledOutcome) => Effect.Effect<void>;
 /**

package/dist/src/plan/operation-events.js

@@ -234,8 +234,9 @@ const unitStateForExit = (exit) => Exit.isSuccess(exit)
 /**
  * Run one unit of work under the lifecycle: `UnitStarted` before, then
  * `UnitResolved` with the state the exit proves (`committed`, `failed`, or
- * `interrupted`). The unit identity is provided to the run so nested producers
- * can publish progress. No-op wrapper without a broadcast.
+ * `interrupted`) and the label the unit settles with. The unit identity is
+ * provided to the run so nested producers can publish progress. No-op wrapper
+ * without a broadcast.
  */
 export const observeUnit = (unit, effect) => Effect.flatMap(Effect.serviceOption(OperationLifecycle), (service) => {
     if (Option.isNone(service))
@@ -259,13 +260,24 @@ export const observeUnit = (unit, effect) => Effect.flatMap(Effect.serviceOption
             seq,
             atMs,
             unitId: unit.id,
-            label: unit.label,
+            label: Exit.isSuccess(exit) && unit.resolvedLabel !== undefined
+                ? unit.resolvedLabel(exit.value)
+                : unit.label,
             state: unitStateForExit(exit),
             index,
             ...total,
         }))));
     });
 });
+/**
+ * Run a unit as a child of the unit currently in progress, so work a step
+ * delegates nests under the step that delegated it. Identical to
+ * `observeUnit` when no unit is in progress, and when the caller states its
+ * own parent that statement wins.
+ */
+export const observeChildUnit = (unit, effect) => Effect.flatMap(Effect.serviceOption(CurrentOperationUnit), (parent) => observeUnit(unit.parentUnitId !== undefined || Option.isNone(parent)
+    ? unit
+    : { ...unit, parentUnitId: parent.value.unitId }, effect));
 /** Publish the terminal event once. No-op without a broadcast. */
 export const settleOperation = (outcome) => withLifecycle((service) => service.settle(outcome), () => Effect.void);
 /**

package/dist/src/plan/plan-execution-fixtures.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Plan-execution fixtures for tests and executable specifications.
+ *
+ * Production commands convert their parsed intent into a `PlanExecution` at
+ * the CLI boundary; these constants let kernel and handler tests drive
+ * `previewOrApplyPlan` with an already-decoded approval decision. Production
+ * source never imports this module.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import type { PlanPolicyId } from "./plan.js";
+import { type ConfirmationRecovery, type PlanExecution } from "./plan-execution.js";
+/** An apply whose preapprovable confirmations are already approved. */
+export declare const preapprovedPlanExecution: PlanExecution;
+/** An apply from a route that offers preapproval but received none. */
+export declare const promptablePlanExecution: (recovery: ConfirmationRecovery, acceptedPolicies?: ReadonlySet<PlanPolicyId>) => PlanExecution;
+/** An apply from a route with no preapprovable confirmation. */
+export declare const interactiveOnlyPlanExecution: (recovery: ConfirmationRecovery, acceptedPolicies?: ReadonlySet<PlanPolicyId>) => PlanExecution;
+//# sourceMappingURL=plan-execution-fixtures.d.ts.map

package/dist/src/plan/plan-execution-fixtures.js

@@ -0,0 +1,30 @@
+/**
+ * Plan-execution fixtures for tests and executable specifications.
+ *
+ * Production commands convert their parsed intent into a `PlanExecution` at
+ * the CLI boundary; these constants let kernel and handler tests drive
+ * `previewOrApplyPlan` with an already-decoded approval decision. Production
+ * source never imports this module.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { applyPlanExecution, } from "./plan-execution.js";
+const emptyRecovery = { command: [], arguments: [] };
+/** An apply whose preapprovable confirmations are already approved. */
+export const preapprovedPlanExecution = applyPlanExecution({
+    approval: "preapproved",
+    recovery: emptyRecovery,
+});
+/** An apply from a route that offers preapproval but received none. */
+export const promptablePlanExecution = (recovery, acceptedPolicies) => applyPlanExecution({
+    approval: "prompt-if-interactive",
+    ...(acceptedPolicies === undefined ? {} : { acceptedPolicies }),
+    recovery,
+});
+/** An apply from a route with no preapprovable confirmation. */
+export const interactiveOnlyPlanExecution = (recovery, acceptedPolicies) => applyPlanExecution({
+    approval: "interactive-only",
+    ...(acceptedPolicies === undefined ? {} : { acceptedPolicies }),
+    recovery,
+});
+//# sourceMappingURL=plan-execution-fixtures.js.map

package/dist/src/plan/plan-execution.d.ts

@@ -30,11 +30,25 @@ export interface ConfirmationRecovery {
     readonly command: ReadonlyArray<string>;
     readonly arguments: ReadonlyArray<ConfirmationRecoveryArgument>;
 }
+/**
+ * How an apply may satisfy a confirmable risk condition.
+ *
+ * - `preapproved`: the person supplied explicit preapproval for this
+ *   invocation on a command that offers a preapprovable confirmation.
+ * - `prompt-if-interactive`: the command offers a preapprovable confirmation
+ *   and none was given; a prompt opens when one can, and recovery may
+ *   suggest preapproval.
+ * - `interactive-only`: the command has no preapprovable confirmation. A
+ *   confirmable condition it meets is unexpected for unattended use: it
+ *   prompts when a prompt can open and otherwise blocks naming interactive
+ *   approval, never a preapproval flag the command does not accept.
+ */
+export type ConfirmableRiskApproval = "preapproved" | "prompt-if-interactive" | "interactive-only";
 export type PlanExecutionRequest = {
     readonly mode: "preview";
 } | {
     readonly mode: "apply";
-    readonly confirmableRiskApproval: "prompt-if-interactive" | "preapproved";
+    readonly confirmableRiskApproval: ConfirmableRiskApproval;
     readonly acceptedPolicies: ReadonlySet<PlanPolicyId>;
 };
 /** Invocation-scoped policy input plus safe replay metadata for approval recovery. */
@@ -52,13 +66,11 @@ export type PlanExecution = {
 };
 export declare const previewPlanExecution: PlanExecution;
 export declare const applyPlanExecution: (options: {
-    readonly approval: "prompt-if-interactive" | "preapproved";
+    readonly approval: ConfirmableRiskApproval;
     readonly acceptedPolicies?: ReadonlySet<PlanPolicyId>;
     readonly recovery: ConfirmationRecovery;
     readonly configuredAgentOperations?: ReadonlyArray<ConfiguredAgentOperation>;
 }) => PlanExecution;
-export declare const preapprovedPlanExecution: PlanExecution;
-export declare const promptablePlanExecution: (recovery: ConfirmationRecovery, acceptedPolicies?: ReadonlySet<PlanPolicyId>) => PlanExecution;
 export declare const publicRecoveryValue: (value: string) => ConfirmationRecoveryValue;
 export declare const protectedRecoveryValue: () => ConfirmationRecoveryValue;
 export declare const unclassifiedRecoveryValue: () => ConfirmationRecoveryValue;
@@ -66,10 +78,25 @@ export declare const credentialFreeLocatorRecoveryValue: (value: string) => Conf
 export declare const recoveryOption: (flag: string, value: ConfirmationRecoveryValue) => ConfirmationRecoveryArgument;
 export declare const recoveryPositional: (value: ConfirmationRecoveryValue) => ConfirmationRecoveryArgument;
 export declare const recoverySwitch: (flag: string, enabled: boolean) => ConfirmationRecoveryArgument;
-export declare const renderConfirmationRecoveryCommand: (recovery: ConfirmationRecovery, options?: {
-    readonly includeYes?: boolean;
+/**
+ * How a rendered recovery command obtains approval.
+ *
+ * - `preapprovable`: the route accepts preapproval, so the replay appends it.
+ * - `interactive`: approval can only be given at a prompt, so the replay drops
+ *   the switches that prohibit one and appends nothing.
+ * - `none`: the replay carries neither; used when a named policy override is
+ *   the missing input.
+ */
+export type RecoveryApproval = "preapprovable" | "interactive" | "none";
+export declare const renderConfirmationRecoveryCommand: (recovery: ConfirmationRecovery, options: {
+    readonly approval: RecoveryApproval;
     readonly additionalSwitches?: ReadonlyArray<string>;
 }) => string | undefined;
 export declare const namedPolicyRecoverySuggestions: (recovery: ConfirmationRecovery, requiredFlags: ReadonlyArray<string>) => ReadonlyArray<SuggestedAction>;
-export declare const confirmationRecoverySuggestions: (recovery: ConfirmationRecovery) => ReadonlyArray<SuggestedAction>;
+/**
+ * The recovery a blocked confirmation offers. A preapprovable confirmation
+ * replays the invocation with explicit preapproval; an interactive-only one
+ * names the need for a prompt and the mode changes that let one open.
+ */
+export declare const confirmationRecoverySuggestions: (recovery: ConfirmationRecovery, approval: Exclude<RecoveryApproval, "none">) => ReadonlyArray<SuggestedAction>;
 //# sourceMappingURL=plan-execution.d.ts.map

package/dist/src/plan/plan-execution.js

@@ -10,16 +10,6 @@ export const applyPlanExecution = (options) => ({
         ? {}
         : { configuredAgentOperations: options.configuredAgentOperations }),
 });
-const emptyRecovery = { command: [], arguments: [] };
-export const preapprovedPlanExecution = applyPlanExecution({
-    approval: "preapproved",
-    recovery: emptyRecovery,
-});
-export const promptablePlanExecution = (recovery, acceptedPolicies) => applyPlanExecution({
-    approval: "prompt-if-interactive",
-    ...(acceptedPolicies === undefined ? {} : { acceptedPolicies }),
-    recovery,
-});
 export const publicRecoveryValue = (value) => ({
     _tag: "Public",
     value,
@@ -52,17 +42,20 @@ const quoteShellToken = (value) => value.length > 0 && safeShellToken.test(value
 const isReplayable = (argument) => argument._tag === "Switch" ||
     (argument.value._tag === "Public" && !/[()]/.test(argument.value.value));
 const renderValue = (value) => value._tag === "Public" && !/[()]/.test(value.value) ? quoteShellToken(value.value) : undefined;
-export const renderConfirmationRecoveryCommand = (recovery, options = {}) => {
+const PREAPPROVAL_FLAG = "--yes";
+const PROMPT_PROHIBITING_FLAGS = new Set(["--json", "--non-interactive"]);
+const NON_REPLAYED_FLAGS = new Set(["--preview", PREAPPROVAL_FLAG]);
+export const renderConfirmationRecoveryCommand = (recovery, options) => {
     if (recovery.command.length === 0 || !recovery.arguments.every(isReplayable))
         return undefined;
+    const dropped = (flag) => NON_REPLAYED_FLAGS.has(flag) ||
+        (options.approval === "interactive" && PROMPT_PROHIBITING_FLAGS.has(flag));
     const optionTokens = recovery.arguments.flatMap((argument) => {
         switch (argument._tag) {
             case "Switch":
-                return argument.enabled && argument.flag !== "--preview" && argument.flag !== "--yes"
-                    ? [argument.flag]
-                    : [];
+                return argument.enabled && !dropped(argument.flag) ? [argument.flag] : [];
             case "Option": {
-                if (argument.flag === "--preview" || argument.flag === "--yes")
+                if (dropped(argument.flag))
                     return [];
                 const value = renderValue(argument.value);
                 return value === undefined ? [] : [argument.flag, value];
@@ -84,7 +77,7 @@ export const renderConfirmationRecoveryCommand = (recovery, options = {}) => {
         "axm",
         ...recovery.command,
         ...optionTokens,
-        ...(options.includeYes === false ? [] : ["--yes"]),
+        ...(options.approval === "preapprovable" ? [PREAPPROVAL_FLAG] : []),
         ...(options.additionalSwitches ?? []),
         ...(needsOptionTerminator ? ["--"] : []),
         ...positionalValues,
@@ -93,7 +86,7 @@ export const renderConfirmationRecoveryCommand = (recovery, options = {}) => {
 };
 export const namedPolicyRecoverySuggestions = (recovery, requiredFlags) => {
     const command = renderConfirmationRecoveryCommand(recovery, {
-        includeYes: false,
+        approval: "none",
         additionalSwitches: requiredFlags,
     });
     return command === undefined
@@ -104,8 +97,19 @@ export const namedPolicyRecoverySuggestions = (recovery, requiredFlags) => {
         ]
         : [{ description: "Retry with the required policy override", cmd: command }];
 };
-export const confirmationRecoverySuggestions = (recovery) => {
-    const command = renderConfirmationRecoveryCommand(recovery);
+const INTERACTIVE_APPROVAL_DESCRIPTION = "Approve interactively: rerun in a terminal without --json or --non-interactive and confirm the plan";
+/**
+ * The recovery a blocked confirmation offers. A preapprovable confirmation
+ * replays the invocation with explicit preapproval; an interactive-only one
+ * names the need for a prompt and the mode changes that let one open.
+ */
+export const confirmationRecoverySuggestions = (recovery, approval) => {
+    const command = renderConfirmationRecoveryCommand(recovery, { approval });
+    if (approval === "interactive") {
+        return command === undefined
+            ? [{ description: INTERACTIVE_APPROVAL_DESCRIPTION }]
+            : [{ description: INTERACTIVE_APPROVAL_DESCRIPTION, cmd: command }];
+    }
     return command === undefined
         ? [
             {

package/dist/src/plan/plan.d.ts

@@ -40,10 +40,19 @@ export interface UnitBlocking {
     /** Machine-readable reference to the blocking unit or condition. */
     readonly reference?: string;
 }
+/**
+ * How a confirmable condition may be approved. `preapprovable` (the default
+ * when absent) accepts explicit preapproval from a command that offers it;
+ * `interactive-only` accepts only an affirmative answer at a prompt, so no
+ * flag and no unattended mode can satisfy it.
+ */
+export declare const ConfirmableConsentSchema: Schema.Literals<readonly ["preapprovable", "interactive-only"]>;
+export type ConfirmableConsent = typeof ConfirmableConsentSchema.Type;
 export declare const PlanRiskConditionSchema: Schema.Union<readonly [Schema.Struct<{
     readonly level: Schema.Literal<"confirmable">;
     readonly id: Schema.String;
     readonly detail: Schema.String;
+    readonly consent: Schema.optional<Schema.Literals<readonly ["preapprovable", "interactive-only"]>>;
 }>, Schema.Struct<{
     readonly level: Schema.Literal<"override-required">;
     readonly id: Schema.String;
@@ -102,6 +111,21 @@ export interface JobStepArtifactSource {
     readonly directory?: string;
     readonly gitTreeHash?: string;
 }
+/**
+ * The Registry identity a step proposes to accept. Trust classification
+ * compares it with the accepted resolution for the same configured target,
+ * so a change of publisher is identified from structured data rather than
+ * from warning text.
+ */
+export interface RegistryBindingProposal {
+    readonly extensionType: ExtensionType;
+    /** The configured (local) name whose accepted resolution the step replaces. */
+    readonly target: string;
+    readonly owner: string;
+    readonly packageName: string;
+    readonly version: string;
+    readonly publisherBindingId: string;
+}
 export interface RegistryLifecycleEvidence {
     readonly deprecation: DeprecationView;
 }
@@ -132,6 +156,7 @@ export interface ReadyJobStep<Requirements = never, Output = never> {
     readonly artifact?: JobStepArtifact;
     readonly agentOutcomes?: ReadonlyArray<ConfiguredAgentOutcome>;
     readonly registryLifecycle?: RegistryLifecycleEvidence;
+    readonly registryBinding?: RegistryBindingProposal;
     readonly run: Effect.Effect<JobStepResult<Output>, StepFailure, Requirements>;
 }
 export interface WarnJobStep<Requirements = never, Output = never> {
@@ -143,6 +168,7 @@ export interface WarnJobStep<Requirements = never, Output = never> {
     readonly artifact?: JobStepArtifact;
     readonly agentOutcomes?: ReadonlyArray<ConfiguredAgentOutcome>;
     readonly registryLifecycle?: RegistryLifecycleEvidence;
+    readonly registryBinding?: RegistryBindingProposal;
     readonly run: Effect.Effect<JobStepResult<Output>, StepFailure, Requirements>;
 }
 export interface ErrorJobStep {
@@ -154,6 +180,7 @@ export interface ErrorJobStep {
     readonly artifact?: JobStepArtifact;
     readonly agentOutcomes?: ReadonlyArray<ConfiguredAgentOutcome>;
     readonly registryLifecycle?: RegistryLifecycleEvidence;
+    readonly registryBinding?: RegistryBindingProposal;
     /** Semantic blockers already represented in Plan.riskConditions. */
     readonly blockingConditionIds?: ReadonlyArray<string>;
 }

package/dist/src/plan/plan.js

@@ -40,11 +40,19 @@ export const BlockingClassSchema = Schema.Literals([
     title: "Blocking Class",
     description: "Bounded reason class for work that did not proceed.",
 });
+/**
+ * How a confirmable condition may be approved. `preapprovable` (the default
+ * when absent) accepts explicit preapproval from a command that offers it;
+ * `interactive-only` accepts only an affirmative answer at a prompt, so no
+ * flag and no unattended mode can satisfy it.
+ */
+export const ConfirmableConsentSchema = Schema.Literals(["preapprovable", "interactive-only"]);
 export const PlanRiskConditionSchema = Schema.Union([
     Schema.Struct({
         level: Schema.Literal("confirmable"),
         id: Schema.String,
         detail: Schema.String,
+        consent: Schema.optional(ConfirmableConsentSchema),
     }),
     Schema.Struct({
         level: Schema.Literal("override-required"),

package/dist/src/plan/resolve-plan.js

@@ -281,31 +281,42 @@ export const previewOrApplyPlan = Effect.fn("previewOrApplyPlan")(function* (pla
             suggestions: escapes,
         });
     }
+    // Step 5b: Confirmation. A condition that consents only at a prompt — a
+    // publisher change, or any confirmable condition met by a command with no
+    // preapprovable confirmation — is never satisfied by preapproval. A
+    // preapprovable condition is satisfied by explicit preapproval; otherwise
+    // it is asked when a prompt can open and blocks when one cannot, naming
+    // the recovery its route actually supports.
     const hasSteps = candidatePlan.jobs.some((job) => job.steps.length > 0);
-    if (hasSteps &&
-        hasConfirmableRisk &&
-        applyExecution.request.confirmableRiskApproval === "prompt-if-interactive") {
-        if (!(yield* interaction.isConfirmationAvailable)) {
-            const confirmable = riskConditions.find((condition) => condition.level === "confirmable");
-            const escapes = confirmationRecoverySuggestions(applyExecution.approvalRecovery);
-            return makeOperationResolution({
-                ...resolutionBase,
-                atomicity: { declared: atomicity, applied: "closure-atomic" },
-                units: plannedUnits(candidatePlan.jobs),
-                blocking: {
-                    class: "approval-required",
-                    subject: confirmable?.id ?? candidatePlan.name,
-                    phase: "confirmation",
-                    detail: confirmable?.detail ?? "This plan requires confirmation before it can apply.",
-                    ...(escapes[0] === undefined ? {} : { escape: escapes[0] }),
-                },
-                suggestions: escapes,
-            });
-        }
-        yield* enterPhase("confirmation");
-        const confirmation = yield* interaction.confirmApplyChanges(applyExecution.approvalRecovery);
-        if (confirmation !== "approved") {
-            return notExecuted({ declined: true });
+    if (hasSteps && hasConfirmableRisk) {
+        const approval = applyExecution.request.confirmableRiskApproval;
+        const interactiveOnly = riskConditions.find((condition) => condition.level === "confirmable" && condition.consent === "interactive-only");
+        const requiresPrompt = interactiveOnly !== undefined || approval === "interactive-only";
+        if (requiresPrompt || approval === "prompt-if-interactive") {
+            if (!(yield* interaction.isConfirmationAvailable)) {
+                const confirmable = interactiveOnly ?? riskConditions.find((condition) => condition.level === "confirmable");
+                const escapes = confirmationRecoverySuggestions(applyExecution.approvalRecovery, requiresPrompt ? "interactive" : "preapprovable");
+                return makeOperationResolution({
+                    ...resolutionBase,
+                    atomicity: { declared: atomicity, applied: "closure-atomic" },
+                    units: plannedUnits(candidatePlan.jobs),
+                    blocking: {
+                        class: "approval-required",
+                        subject: confirmable?.id ?? candidatePlan.name,
+                        phase: "confirmation",
+                        detail: requiresPrompt
+                            ? `${confirmable?.detail ?? "This plan requires confirmation before it can apply."} Interactive approval is required; preapproval does not apply.`
+                            : (confirmable?.detail ?? "This plan requires confirmation before it can apply."),
+                        ...(escapes[0] === undefined ? {} : { escape: escapes[0] }),
+                    },
+                    suggestions: escapes,
+                });
+            }
+            yield* enterPhase("confirmation");
+            const confirmation = yield* interaction.confirmApplyChanges(applyExecution.approvalRecovery);
+            if (confirmation !== "approved") {
+                return notExecuted({ declined: true });
+            }
         }
     }
     // Step 6: Acquire the workspace transition — planning, network acquisition,

package/dist/src/testing.d.ts

@@ -8,4 +8,5 @@
  * @packageDocumentation
  */
 export { ResolvePlanInteractionTest, type ResolvePlanInteractionTestState, } from "./plan/resolve-plan-interaction.js";
+export { interactiveOnlyPlanExecution, preapprovedPlanExecution, promptablePlanExecution, } from "./plan/plan-execution-fixtures.js";
 //# sourceMappingURL=testing.d.ts.map

package/dist/src/testing.js

@@ -8,4 +8,5 @@
  * @packageDocumentation
  */
 export { ResolvePlanInteractionTest, } from "./plan/resolve-plan-interaction.js";
+export { interactiveOnlyPlanExecution, preapprovedPlanExecution, promptablePlanExecution, } from "./plan/plan-execution-fixtures.js";
 //# sourceMappingURL=testing.js.map

package/package.json

@@ -1,64 +1,64 @@
 {
-  "name": "@agentxm/workspace-operations",
-  "version": "0.28.7-preview.1788522540.63ba4b89a",
-  "description": "AXM workspace operations kernel: plans, execution candidates, operation resolutions, and workspace transactions 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/workspace-operations"
+  "dependencies": {
+    "@agentxm/extension-model": "^0.28.8",
+    "@agentxm/registry-protocol": "^0.28.8",
+    "@agentxm/workspace-state": "^0.28.8",
+    "effect": "4.0.0-rc.112",
+    "proper-lockfile": "^4.1.2"
+  },
+  "description": "AXM workspace operations kernel: plans, execution candidates, operation resolutions, and workspace transactions 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/proper-lockfile": "^4.1.4",
+    "@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"
     },
     "./testing": {
-      "types": "./dist/src/testing.d.ts",
       "axm-source": "./src/testing.ts",
-      "default": "./dist/src/testing.js"
+      "default": "./dist/src/testing.js",
+      "types": "./dist/src/testing.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/workspace-operations",
   "nx": {
     "includedScripts": []
   },
-  "dependencies": {
-    "effect": "4.0.0-rc.112",
-    "proper-lockfile": "^4.1.2",
-    "@agentxm/extension-model": "^0.28.7-preview.1788522540.63ba4b89a",
-    "@agentxm/registry-protocol": "^0.28.7-preview.1788522540.63ba4b89a",
-    "@agentxm/workspace-state": "^0.28.7-preview.1788522540.63ba4b89a"
+  "publishConfig": {
+    "access": "public"
   },
-  "devDependencies": {
-    "@effect/platform-node": "4.0.0-rc.112",
-    "@effect/vitest": "4.0.0-rc.112",
-    "@types/proper-lockfile": "^4.1.4",
-    "@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/workspace-operations",
+    "type": "git",
+    "url": "https://github.com/agentxm/axm.git"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "version": "0.28.8"
+}