@black-market/sdk 0.14.1 → 0.15.1

package/dist/lifecycle/planner.js

@@ -5,17 +5,39 @@ import { launchLifecycleAbi, lifecycleAdapterAbi, lifecycleErc20Abi } from "./ab
 import { hashLaunchIdentity, hashLaunchPlan, LifecycleFundingKind, LifecyclePhase, LifecycleRewardMode, LifecycleTokenKind, LIFECYCLE_MAX_REWARD_ERC20_SUPPLY, LIFECYCLE_MAX_ERC404_SUPPLY, parseLaunchPlan, serializeLaunchPlan } from "./schema.js";
 import { readLaunchProgress, readLifecycleExecutionProgress, readLifecycleHeadProgress, readLifecycleProfiles, readLifecycleTokenAtBlock, readPoolBoundHookDeployment } from "./progress.js";
 import { decodeAbyssLifecycleMarketConfig, decodePoolBoundV4LifecycleMarketConfig, decodeV4LifecycleMarketConfig, encodePoolBoundV4LifecycleMarketConfig, isPoolBoundV4ConfigVersion } from "./markets.js";
-import { assertLifecycleReadClientOpen, lifecycleFailureReason, lifecyclePinnedRpc, lifecycleStaticRpc, lifecycleRpc, lifecycleStage, readLifecycleChainId, readLifecycleContract, readLifecycleGasPrice, resolveLifecycleLimits, rpcHex, rpcQuantity, withLifecycleReadClient } from "./rpc.js";
-import { prepareLaunchSimulation, simulateLaunchTransactions } from "./simulation.js";
+import { lifecyclePinnedRpc, lifecycleStaticRpc, lifecycleStage, nitroPosterGasBound, readLifecycleChainId, readLifecycleContract, readNitroPrices, registerLifecycleFinalCheck, resolveLifecycleLimits, rpcHex, rpcQuantity, withLifecycleReadClient } from "./rpc.js";
 import { LifecyclePlanningError } from "./types.js";
-import { deriveKnownPoolBoundHookDeployment, protectOrderedBuyMinimums, validateBuySlippageBps } from "./calibration.js";
+import { deriveKnownPoolBoundHookDeployment, validateBuySlippageBps } from "./calibration.js";
 import { getKnownLifecycleDeployment, getKnownLifecycleProfile } from "./presets.js";
-import { buildLaunchTransactions, packPreparationBatches } from "./transactions.js";
+import { buildLifecycleCommand, packPreparationBatches } from "./transactions.js";
 import { assertLifecycleMarketAllocation, assertLifecycleSupplyAllocation } from "./allocations.js";
-import { assertUfgLaunchAccount, hashUfgLaunchConfig, UFG_LAUNCH_PROXY_ADDRESS } from "./ufg-config.js";
-import { buildUfgLaunchTransactions, buildUfgCancelTransaction, validateUfgLaunchPlan } from "./ufg.js";
+import { assertUfgLaunchAccount, hashUfgLaunchConfig, ufgPlanPrincipal, UFG_LAUNCH_PROXY_ADDRESS } from "./ufg-config.js";
+import { buildUfgCancelTransaction, validateUfgLaunchPlan } from "./ufg.js";
 import { readLifecyclePlanningBlock } from "./snapshot.js";
 import { mineLifecycleHooks } from "./mining.js";
+import { computeLifecycleOpeningBuys, hasProfiledOpeningMath } from "./opening-buys.js";
+import { assessLifecycleTransactions, deriveLifecycleLaunchCapacity } from "./gas-profile.js";
+const defaultPlanReadContext = {};
+function observedFields(value) {
+    const keys = Object.keys(value);
+    const values = keys.map((key) => value[key]);
+    return () => keys.length === Object.keys(value).length && keys.every((key, index) => value[key] === values[index]);
+}
+async function selectLaunchMode(requested, plan, capacity, limits, client, block) {
+    if (requested !== "atomic" || plan.markets.length !== 1 || plan.funding.some((funding) => funding.kind === LifecycleFundingKind.Swap) ||
+        capacity?.atomic === undefined || capacity.bounds.atomicComputeGasUpperBound === undefined)
+        return "staged";
+    const poster = limits.protocol === "nitro" ? nitroPosterGasBound(capacity.atomic, await readNitroPrices(client, block)).posterGas : 0n;
+    return capacity.bounds.atomicComputeGasUpperBound + poster <= limits.executionGasCeiling ? "atomic" : "staged";
+}
+async function preparationBatches(plan, prepared, ufg, limits, client, block) {
+    if (prepared === plan.markets.length)
+        return prepared === 0 ? [] : [prepared];
+    const route = ufg === undefined ? undefined : { account: ufgPlanPrincipal(plan), config: ufg.config };
+    const sample = buildLifecycleCommand(plan, { kind: "prepare", first: prepared, count: 1 }, route);
+    const poster = limits.protocol === "nitro" ? nitroPosterGasBound(sample, await readNitroPrices(client, block)).posterGas : 0n;
+    return packPreparationBatches(plan, prepared, limits.executionGasCeiling - poster, limits.headroomBps);
+}
 function validatePlanShape(plan) {
     // Encoding checks all exact integer widths, addresses, byte strings and tuple fields.
     const commitment = hashLaunchPlan(plan);
@@ -152,28 +174,42 @@ async function readPlanMetadata(client, plan, token, block) {
     }))).filter((deployment) => deployment !== undefined);
     return { profiles, hookDeployments, reasons: live.filter((profile) => !profile.admitted).map((profile) => profile.reason ?? "Unlisted lifecycle profile is unavailable") };
 }
-function orderedTransactions(plan, mode, progress, approvals, batches, ufg) {
+function orderedTransactions(plan, mode, progress, approvals, batches, ufg, capacity) {
     if (progress.canonical.phase === LifecyclePhase.Active || progress.canonical.phase === LifecyclePhase.Cancelled)
         return [];
-    const prepared = progress.canonical.preparedMarkets;
-    const compiled = ufg === undefined ? buildLaunchTransactions({ plan, mode, preparationBatches: mode === "staged" ? batches : undefined })
-        : buildUfgLaunchTransactions({ plan, config: ufg.config, mode, preparationBatches: mode === "staged" ? batches : undefined });
+    const prepared = progress.canonical.preparedMarkets, route = ufg === undefined ? undefined : { account: ufgPlanPrincipal(plan), config: ufg.config };
+    const compiled = [];
+    if (mode === "atomic")
+        compiled.push(capacity?.atomic ?? buildLifecycleCommand(plan, { kind: "atomic" }, route));
+    else {
+        compiled.push(buildLifecycleCommand(plan, { kind: "begin" }, route));
+        let first = 0;
+        for (const count of batches) {
+            compiled.push(buildLifecycleCommand(plan, { kind: "prepare", first, count }, route));
+            first += count;
+        }
+        compiled.push(capacity?.activation ?? buildLifecycleCommand(plan, { kind: "activate" }, route));
+    }
     const commands = compiled.filter((transaction) => (transaction.kind !== "begin" && transaction.kind !== "atomic" || progress.canonical.phase === LifecyclePhase.None) &&
         (transaction.kind !== "prepare" || (transaction.marketStart ?? 0) >= prepared));
     const transactions = progress.canonical.phase === LifecyclePhase.None ? [...approvals, ...commands] : commands;
-    return transactions.map((transaction, index) => ({ ...transaction, nonce: progress.pendingAccountNonce + BigInt(index), calldataBytes: (transaction.data.length - 2) / 2, dependencies: index === 0 ? [] : [transactions[index - 1].id] }));
+    return transactions.map((transaction, index) => ({ ...transaction, calldataBytes: (transaction.data.length - 2) / 2, dependencies: index === 0 ? [] : [transactions[index - 1].id] }));
 }
-function attachEstimates(transactions, simulation) {
-    return transactions.map((transaction) => {
-        const estimate = simulation.steps.find((step) => step.transactionId === transaction.id)?.estimate;
-        return { ...transaction, calldataBytes: (transaction.data.length - 2) / 2, gas: estimate?.gasLimit, gasPrice: estimate?.gasPrice, estimate,
-            admission: estimate === undefined ? undefined : { admitted: simulation.admitted, confidence: simulation.confidence, executionProof: simulation.executionProof, protocolFit: simulation.protocolFit, transportPreflight: simulation.transportPreflight, blockNumber: simulation.blockNumber, blockHash: simulation.blockHash, account: simulation.account, chainId: simulation.chainId, reason: simulation.reason, limits: simulation.limits } };
+function attachEstimates(transactions, assessment) {
+    return transactions.map((transaction, index) => {
+        if (index !== 0)
+            return transaction;
+        if (transaction.kind === "approve" || transaction.kind === "approve-reset")
+            return { ...transaction, assessment };
+        const estimate = assessment.estimate;
+        return { ...transaction, calldataBytes: (transaction.data.length - 2) / 2, gas: estimate?.gasLimit, gasPrice: estimate?.gasPrice, estimate, assessment };
     });
 }
 const reviewedTransactionKinds = ["approve-reset", "approve", "atomic", "begin", "prepare", "activate", "cancel"];
 function readReviewedNextTransaction(transaction) {
     if (transaction === undefined)
         return undefined;
+    const walletApproval = transaction?.kind === "approve" || transaction?.kind === "approve-reset";
     if (transaction === null || typeof transaction !== "object" || typeof transaction.id !== "string" ||
         !reviewedTransactionKinds.includes(transaction.kind) ||
         !Number.isSafeInteger(transaction.chainId) || transaction.chainId <= 0 ||
@@ -181,9 +217,8 @@ function readReviewedNextTransaction(transaction) {
         typeof transaction.to !== "string" || !/^0x[\da-fA-F]{40}$/.test(transaction.to) ||
         typeof transaction.data !== "string" || !/^0x(?:[\da-fA-F]{2})*$/.test(transaction.data) ||
         typeof transaction.value !== "bigint" || transaction.value < 0n || transaction.value >= 1n << 256n ||
-        typeof transaction.gas !== "bigint" || transaction.gas <= 0n || transaction.gas >= 1n << 64n ||
-        typeof transaction.gasPrice !== "bigint" || transaction.gasPrice < 0n || transaction.gasPrice >= 1n << 256n ||
-        transaction.nonce !== undefined && (typeof transaction.nonce !== "bigint" || transaction.nonce < 0n || transaction.nonce >= 1n << 64n)) {
+        !walletApproval && (typeof transaction.gas !== "bigint" || transaction.gas <= 0n || transaction.gas >= 1n << 64n ||
+            typeof transaction.gasPrice !== "bigint" || transaction.gasPrice < 0n || transaction.gasPrice >= 1n << 256n)) {
         throw new LifecyclePlanningError("INVALID_REVIEWED_TRANSACTION", "Reviewed transaction must contain a well-formed exact chain/account/target/calldata/value and uint64 gas/uint256 price envelope");
     }
     return transaction;
@@ -191,23 +226,22 @@ function readReviewedNextTransaction(transaction) {
 function matchesReviewedNextTransaction(next, reviewed) {
     return next !== undefined && next.id === reviewed.id && next.kind === reviewed.kind && next.chainId === reviewed.chainId &&
         next.from.toLowerCase() === reviewed.from.toLowerCase() && next.to.toLowerCase() === reviewed.to.toLowerCase() &&
-        next.data.toLowerCase() === reviewed.data.toLowerCase() && next.value === reviewed.value &&
-        (reviewed.nonce === undefined || next.nonce === reviewed.nonce);
+        next.data.toLowerCase() === reviewed.data.toLowerCase() && next.value === reviewed.value;
 }
 function assertReviewedTransactionUnchanged(options, reviewed, next) {
     if (options.planned.ufg !== undefined)
         assertUfgLaunchAccount(options.planned.plan, options.planned.account);
     if (options.planned.account.toLowerCase() !== next.from.toLowerCase() || options.planned.ufg === undefined && options.planned.plan.creator.toLowerCase() !== next.from.toLowerCase()) {
-        throw new LifecyclePlanningError("ACCOUNT_MISMATCH", "Execution account changed during fresh execution or submission proof");
+        throw new LifecyclePlanningError("ACCOUNT_MISMATCH", "Execution account changed while preparing the reviewed transaction");
     }
     if (options.planned.chainId !== BigInt(next.chainId) || options.planned.plan.chainId !== BigInt(next.chainId)) {
-        throw new LifecyclePlanningError("CHAIN_MISMATCH", "Execution chain changed during fresh execution or submission proof");
+        throw new LifecyclePlanningError("CHAIN_MISMATCH", "Execution chain changed while preparing the reviewed transaction");
     }
     const current = readReviewedNextTransaction(options.reviewedTransaction);
-    if (reviewed === undefined ? current !== undefined : current === undefined || !matchesReviewedNextTransaction(current, reviewed) ||
-        current.gas !== reviewed.gas || current.gasPrice !== reviewed.gasPrice || !matchesReviewedNextTransaction(next, reviewed) ||
-        next.gas !== reviewed.gas || next.gasPrice !== reviewed.gasPrice) {
-        throw new LifecyclePlanningError("REVIEWED_TRANSACTION_CHANGED", "Reviewed transaction changed during fresh execution or submission proof");
+    if (reviewed === undefined ? current !== undefined : current === undefined || !matchesReviewedNextTransaction(current, reviewed) || !matchesReviewedNextTransaction(next, reviewed) ||
+        reviewed.kind !== "approve" && reviewed.kind !== "approve-reset" &&
+            (current.gas !== reviewed.gas || current.gasPrice !== reviewed.gasPrice || next.gas !== reviewed.gas || next.gasPrice !== reviewed.gasPrice)) {
+        throw new LifecyclePlanningError("REVIEWED_TRANSACTION_CHANGED", "Reviewed transaction changed while preparing it");
     }
 }
 async function readTokenFactoryBinding(client, orchestrator, block) {
@@ -221,21 +255,6 @@ async function readTokenFactoryBinding(client, orchestrator, block) {
         throw new LifecyclePlanningError("TOKEN_FACTORY_BINDING", "Token factory is not live and bound to the exact lifecycle core");
     return { tokenFactory, tokenFactoryCodeHash: keccak256(code) };
 }
-function assertPlannedDeploymentBindings(stored, current) {
-    if (hashLaunchPlan(stored.plan).toLowerCase() !== stored.planHash.toLowerCase() || current.planHash.toLowerCase() !== stored.planHash.toLowerCase() || current.launchId.toLowerCase() !== stored.launchId.toLowerCase())
-        throw new LifecyclePlanningError("PLAN_MUTATED", "Stored economic plan no longer matches its finalized commitment");
-    if (stored.ufg === undefined ? current.ufg !== undefined : current.ufg === undefined || hashUfgLaunchConfig(stored.ufg.config) !== stored.ufg.configHash || current.ufg.configHash !== stored.ufg.configHash)
-        throw new LifecyclePlanningError("PLAN_MUTATED", "Stored UFG route or treasury config no longer matches its finalized commitment");
-    if (current.predictedToken.toLowerCase() !== stored.predictedToken.toLowerCase() || current.tokenFactory.toLowerCase() !== stored.tokenFactory.toLowerCase() || current.tokenFactoryCodeHash.toLowerCase() !== stored.tokenFactoryCodeHash.toLowerCase())
-        throw new LifecyclePlanningError("TOKEN_FACTORY_BINDING", "Final token prediction or its immutable factory code binding changed before execution");
-    if (!current.simulation.admitted || current.progress.canonical.phase === LifecyclePhase.Active || current.progress.canonical.phase === LifecyclePhase.Cancelled)
-        return;
-    if (stored.hookDeployments.length !== current.hookDeployments.length || stored.hookDeployments.some((deployment, index) => {
-        const fresh = current.hookDeployments[index];
-        return fresh === undefined || fresh.marketIndex !== deployment.marketIndex || fresh.deployer.toLowerCase() !== deployment.deployer.toLowerCase() || fresh.initCodeHash.toLowerCase() !== deployment.initCodeHash.toLowerCase() || fresh.salt.toLowerCase() !== deployment.salt.toLowerCase() || fresh.predictedHook.toLowerCase() !== deployment.predictedHook.toLowerCase();
-    }))
-        throw new LifecyclePlanningError("HOOK_DEPLOYMENT_CHANGED", "Final bound-hook deployer, initcode, salt or prediction changed before wallet execution");
-}
 function assertPlanningActive(signal) {
     if (signal?.aborted)
         throw Object.assign(new Error("Lifecycle launch planning cancelled"), { name: "AbortError" });
@@ -244,7 +263,7 @@ function validatePlanningIntent(options) {
     const { plan, account, mode } = options;
     assertPlanningActive(options.signal);
     if (mode !== "atomic" && mode !== "staged")
-        throw new LifecyclePlanningError("EXPLICIT_MODE_REQUIRED", "Choose atomic or staged explicitly; staged is never silently substituted");
+        throw new LifecyclePlanningError("EXPLICIT_MODE_REQUIRED", "Choose an atomic preference or explicit staged mode");
     if (options.ufg !== undefined)
         assertUfgLaunchAccount(plan, account);
     else if (account.toLowerCase() !== plan.creator.toLowerCase())
@@ -295,21 +314,15 @@ function assertFinalPlan(planned, signal) {
     if (planned.ufg !== undefined && hashUfgLaunchConfig(planned.ufg.config) !== planned.ufg.configHash)
         throw new LifecyclePlanningError("PLAN_MUTATED", "UFG treasury config changed during asynchronous planning");
 }
-/** One owner constructs and mines, optionally measures actual ordered buy outputs,
- * then proves only the final protected commitment. No cached execution certificates. */
+/** One owner mines constructor-bound salts and protects ordered buys with exact
+ * local curve math. Launch calldata is never executed during planning. */
 export async function prepareAndPlanLifecycleLaunch(options) {
     const { commitment, ufgConfigHash } = validatePlanningIntent(options);
     if (options.buySlippageBps !== undefined)
         validateBuySlippageBps(options.buySlippageBps);
-    const fixed = options.fixedFinalEnvelope;
-    if (fixed !== undefined && (fixed === null || typeof fixed !== "object" || options.mode !== "atomic" || typeof fixed.gas !== "bigint" || fixed.gas <= 0n || fixed.gas >= 1n << 64n ||
-        fixed.gasPrice !== undefined && (typeof fixed.gasPrice !== "bigint" || fixed.gasPrice < 0n || fixed.gasPrice >= 1n << 256n))) {
-        throw new LifecyclePlanningError("INVALID_GAS_ENVELOPE", "Fixed final envelope requires atomic mode, exact positive uint64 gas and optional uint256 price");
-    }
-    const heldEnvelope = fixed === undefined ? undefined : Object.freeze({ ...fixed });
     const needsMining = options.plan.markets.some((market) => isPoolBoundV4ConfigVersion(market.configVersion));
     const needsProtection = options.buySlippageBps !== undefined && options.plan.buys.length !== 0;
-    if (!needsMining && !needsProtection && fixed === undefined)
+    if (!needsMining && !needsProtection)
         return planLaunch(options);
     const draft = parseLaunchPlan(serializeLaunchPlan(options.plan));
     const assertDraft = () => {
@@ -318,9 +331,6 @@ export async function prepareAndPlanLifecycleLaunch(options) {
             throw new LifecyclePlanningError("PLAN_MUTATED", "Economic plan changed during asynchronous preparation; previous construction is invalid");
         if ((options.ufg === undefined ? undefined : hashUfgLaunchConfig(options.ufg.config)) !== ufgConfigHash)
             throw new LifecyclePlanningError("PLAN_MUTATED", "UFG config changed during asynchronous preparation");
-        if (fixed === undefined ? options.fixedFinalEnvelope !== undefined : options.fixedFinalEnvelope !== fixed ||
-            fixed.gas !== heldEnvelope.gas || fixed.gasPrice !== heldEnvelope.gasPrice)
-            throw new LifecyclePlanningError("INVALID_GAS_ENVELOPE", "Fixed final envelope changed during preparation");
     };
     const result = await withLifecycleReadClient(options.client, async (client) => {
         const block = await readLifecyclePlanningBlock(client, draft, options.account, options.ufg !== undefined, true);
@@ -344,32 +354,25 @@ export async function prepareAndPlanLifecycleLaunch(options) {
             markets[marketIndex] = { ...market, config: encodePoolBoundV4LifecycleMarketConfig({ ...decodePoolBoundV4LifecycleMarketConfig(market.config, market.configVersion), hookSalt: mined.salt }) };
         }
         assertDraft();
-        const executionBlock = block;
-        assertDraft();
-        const price = heldEnvelope === undefined ? undefined : heldEnvelope.gasPrice ?? rpcQuantity(await readLifecycleGasPrice(client), "gas price");
-        const baseFeeEnvelope = (executionBlock.baseFeePerGas ?? 0n) * 2n;
-        const finalEnvelope = heldEnvelope === undefined ? undefined : Object.freeze({
-            gas: heldEnvelope.gas,
-            gasPrice: heldEnvelope.gasPrice ?? (price > baseFeeEnvelope ? price : baseFeeEnvelope),
-        });
         let plan = { ...draft, markets };
-        let ownedProgress;
-        let sizing;
+        let openingBuys;
         if (needsProtection) {
-            // A diagnostic minimum is never returned as an admitted or executable plan.
-            // Price guards, funding minima, recipients and all ordered budgets stay exact.
-            const diagnosticPlan = { ...plan, buys: plan.buys.map((buy) => ({ ...buy, minTokenOut: 1n })) };
-            const diagnostic = await lifecycleStage(client, "plan", () => planLaunchWithReads({ ...options, plan: diagnosticPlan }, client, executionBlock, undefined, true, finalEnvelope));
-            assertDraft();
-            if (diagnostic.progress.canonical.phase !== LifecyclePhase.None || diagnostic.progress.head.phase !== LifecyclePhase.None)
+            if (!hasProfiledOpeningMath(plan))
+                throw new LifecyclePlanningError("OPENING_BUY_NOT_PROFILED", "Exact opening-buy math is unavailable for this profile. Use a supported profile or update the SDK.");
+            const head = await readLifecycleHeadProgress(client, plan, options.account, block);
+            if (head.phase !== LifecyclePhase.None)
                 throw new LifecyclePlanningError("LAUNCH_ALREADY_STARTED", "Buy protection cannot replace an already committed launch plan");
-            plan = protectOrderedBuyMinimums(diagnostic, options.buySlippageBps);
-            // This is the real SDK-owned None observation, not an assumed new-launch
-            // state. No onchain commitment existed at this exact snapshot to replace.
-            ownedProgress = { ...diagnostic.progress, planHash: hashLaunchPlan(plan) };
-            sizing = new Map(diagnostic.simulation.steps.map((step) => [step.transactionId, step.gasRequired ?? step.gasUsed]));
+            const predictedToken = await readLifecycleTokenAtBlock(client, plan, block);
+            openingBuys = computeLifecycleOpeningBuys({ plan, predictedToken });
+            const factor = BigInt(10000 - options.buySlippageBps);
+            plan = { ...plan, buys: plan.buys.map((buy, index) => {
+                    const minTokenOut = openingBuys[index].tokenOut * factor / 10000n;
+                    if (minTokenOut <= 0n)
+                        throw new LifecyclePlanningError("INVALID_BUY_OUTPUT", "Each opening buy must produce a positive protected minimum");
+                    return { ...buy, minTokenOut };
+                }) };
         }
-        const planned = await lifecycleStage(client, "plan", () => planLaunchWithReads({ ...options, plan }, client, executionBlock, ownedProgress, false, finalEnvelope, sizing));
+        const planned = await lifecycleStage(client, "plan", () => planLaunchWithReads({ ...options, plan }, client, { block, openingBuys }));
         assertDraft();
         assertFinalPlan(planned, options.signal);
         if (planned.progress.canonical.phase !== LifecyclePhase.Active && planned.progress.canonical.phase !== LifecyclePhase.Cancelled) {
@@ -379,15 +382,15 @@ export async function prepareAndPlanLifecycleLaunch(options) {
                     throw new LifecyclePlanningError("HOOK_DEPLOYMENT_CHANGED", "Final exact constructor binding differs from the one locally mined candidate");
             }
         }
-        if (needsProtection && !planned.simulation.admitted)
-            throw new LifecyclePlanningError("PROTECTED_PLAN_NOT_ADMITTED", planned.simulation.reason ?? "The final protected launch did not establish exact execution proof", planned.simulation);
+        if (needsProtection && !planned.assessment.ready)
+            throw new LifecyclePlanningError(planned.assessment.code ?? "PLAN_NOT_READY", planned.assessment.reason ?? "The launch could not be prepared. Refresh the review before continuing.", planned.assessment);
         return planned;
     });
     assertDraft();
     assertFinalPlan(result, options.signal);
     return result;
 }
-/** Independently fresh current-state admission of an already finalized commitment. No broadcasts. */
+/** Fresh pinned input and deterministic gas-budget checks. No simulation or broadcasts. */
 export async function planLaunch(options) {
     const result = await withLifecycleReadClient(options.client, async (client) => {
         const planned = await lifecycleStage(client, "plan", () => planLaunchWithReads(options, client));
@@ -397,8 +400,9 @@ export async function planLaunch(options) {
     assertFinalPlan(result, options.signal);
     return result;
 }
-async function planLaunchWithReads(options, client, pinnedBlock, ownedProgress, diagnostic = false, fixedFinalEnvelope, sizing) {
-    const { plan, account, mode, ufg } = options;
+async function planLaunchWithReads(options, client, readContext = defaultPlanReadContext) {
+    const { block: pinnedBlock, openingBuys } = readContext;
+    const { plan, account, ufg } = options;
     const { commitment: planHash, marketConfigs, ufgConfigHash } = validatePlanningIntent(options);
     const launchId = hashLaunchIdentity(plan);
     const [block, chainId] = await lifecycleStage(client, "plan.context", () => Promise.all([
@@ -406,39 +410,27 @@ async function planLaunchWithReads(options, client, pinnedBlock, ownedProgress,
     ]));
     if (chainId !== plan.chainId)
         throw new LifecyclePlanningError("CHAIN_MISMATCH", "RPC chain differs from the committed plan");
-    // Only preparation/build-next can supply freshly observed progress from this
-    // still-open SDK invocation. Stored/query DTOs never enter this continuation.
-    if (ownedProgress !== undefined) {
-        if (!assertLifecycleReadClientOpen(client) || pinnedBlock !== block || ownedProgress.blockNumber !== block.number ||
-            ownedProgress.blockHash.toLowerCase() !== block.hash.toLowerCase() || ownedProgress.chainId !== plan.chainId ||
-            ownedProgress.confirmationDepth !== (options.confirmations ?? 1))
-            throw new LifecyclePlanningError("INVALID_READ_CONTEXT", "Owned progress differs from its active planning snapshot");
-        if (ownedProgress.planHash.toLowerCase() !== planHash.toLowerCase() || ownedProgress.launchId.toLowerCase() !== launchId.toLowerCase())
-            throw new LifecyclePlanningError("PLAN_MUTATED", "Economic plan changed after its canonical progress was read");
-    }
     assertPlanningActive(options.signal);
     const preset = getKnownLifecycleDeployment({ chainId: plan.chainId, orchestrator: plan.orchestrator });
     const [{ tokenFactory, tokenFactoryCodeHash }, { limits }, { identity, progress }] = await lifecycleStage(client, "plan.domain", () => Promise.all([
         preset ?? readTokenFactoryBinding(client, plan.orchestrator, block),
         resolveLifecycleLimits({ client, account, orchestrator: plan.orchestrator, block, chainId: plan.chainId }, options.limits),
         lifecycleStage(client, "plan.progress", async () => {
-            const [predictedToken] = await Promise.all([
-                readLifecycleTokenAtBlock(client, plan, block),
-                ownedProgress === undefined ? readLifecycleHeadProgress(client, plan, account, block) : undefined,
+            const [predictedToken, head] = await Promise.all([
+                readLifecycleTokenAtBlock(client, plan, block), readLifecycleHeadProgress(client, plan, account, block),
             ]);
+            const mode = head.phase === LifecyclePhase.None ? options.mode : head.mode === 1 ? "staged" : "atomic";
             const identity = { plan, planHash, launchId, predictedToken, account, mode, confirmations: options.confirmations ?? 1,
                 ...(ufg === undefined ? {} : { ufg: { config: ufg.config, configHash: ufgConfigHash } }) };
             if (ufg !== undefined)
                 validateUfgLaunchPlan(plan, ufg.config, predictedToken);
-            const progress = ownedProgress ?? await readLaunchProgress({ client, planned: identity, receipts: options.receipts, signal: options.signal }, block);
-            if (ownedProgress !== undefined && progress.token.toLowerCase() !== predictedToken.toLowerCase())
-                throw new LifecyclePlanningError("TOKEN_IDENTITY", "Predicted token changed after its canonical progress was read");
+            const progress = await readLaunchProgress({ client, planned: identity, receipts: options.receipts, signal: options.signal }, block);
             return { identity, progress };
         }),
     ]));
     assertPlanningActive(options.signal);
-    const placeholder = { backend: "unavailable", confidence: "provisional", admitted: false, executionProof: "unavailable", protocolFit: "unknown", transportPreflight: "not-requested", blockNumber: block.number, blockHash: block.hash, account, chainId: plan.chainId, limits, steps: [], deferredTransactionIds: [] };
-    let planned = { ...identity, tokenFactory, tokenFactoryCodeHash, chainId: plan.chainId, transactions: [], totalCalldataBytes: 0, prerequisites: [], profiles: [], hookDeployments: [], progress, simulation: placeholder, limits: options.limits,
+    const placeholder = { ready: false, blockNumber: block.number, blockHash: block.hash, account, chainId: plan.chainId, limits };
+    let planned = { ...identity, tokenFactory, tokenFactoryCodeHash, chainId: plan.chainId, transactions: [], totalCalldataBytes: 0, prerequisites: [], profiles: [], hookDeployments: [], progress, assessment: placeholder, limits: options.limits,
         allowTopologyGaps: options.allowTopologyGaps === true, allowMissingPermanentTail: options.allowMissingPermanentTail === true };
     const receiptsPending = progress.receipts.some((receipt) => receipt.status === "pending" || receipt.status === "unconfirmed");
     if (!progress.confirmationSafe || receiptsPending) {
@@ -450,14 +442,13 @@ async function planLaunchWithReads(options, client, pinnedBlock, ownedProgress,
             const known = deriveKnownPoolBoundHookDeployment({ plan, token: identity.predictedToken, marketIndex });
             hookDeployments.push({ marketIndex, ...(known?.deployment ?? await readPoolBoundHookDeployment({ client, plan, marketIndex }, block)) });
         }
-        const waiting = { ...placeholder, confidence: "stateful", reason: !progress.confirmationSafe ? "Canonical confirmed progress/account nonce has not caught up with head or pending transactions; wait for the selected confirmation depth" : "Wait for canonical receipt confirmations or resolve replacement before requesting another transaction" };
-        return { ...planned, hookDeployments, simulation: waiting };
+        return { ...planned, hookDeployments, assessment: { ...placeholder,
+                code: !progress.confirmationSafe ? "UNCONFIRMED_STATE" : "RECEIPT_PENDING",
+                reason: !progress.confirmationSafe ? "Wait for the selected launch confirmation depth before continuing." : "Wait for the pending transaction to confirm or resolve its replacement." } };
     }
     if (progress.canonical.phase === LifecyclePhase.Active || progress.canonical.phase === LifecyclePhase.Cancelled) {
-        return { ...planned, simulation: { ...placeholder, confidence: "stateful", executionProof: "proved", protocolFit: "proved", admitted: true, reason: "Canonical launch is terminal; no transaction remains" } };
+        return { ...planned, assessment: { ...placeholder, ready: true } };
     }
-    // Topology is a creation policy, not a retroactive obstacle to recovery of
-    // immutable onchain commitments. Waiting and terminal launches returned above.
     if (progress.canonical.phase === LifecyclePhase.None && progress.head.phase === LifecyclePhase.None)
         validatePlanTopology(options, marketConfigs, identity.predictedToken);
     const [funding, metadata] = await lifecycleStage(client, "plan.inputs", () => Promise.all([
@@ -465,199 +456,118 @@ async function planLaunchWithReads(options, client, pinnedBlock, ownedProgress,
         readPlanMetadata(client, plan, identity.predictedToken, block),
     ]));
     assertFinalPlan(planned, options.signal);
-    planned = { ...planned, prerequisites: funding.prerequisites, profiles: metadata.profiles, hookDeployments: metadata.hookDeployments };
-    const prepared = progress.canonical.preparedMarkets;
-    const computeCap = limits.transactionGasCeiling !== undefined && limits.transactionGasCeiling < limits.executionGasCeiling ? limits.transactionGasCeiling : limits.executionGasCeiling;
-    let batches = [];
-    if (mode === "staged")
-        batches = packPreparationBatches(plan, prepared, computeCap);
-    let transactions = orderedTransactions(plan, mode, progress, funding.approvals, batches, ufg);
-    if (fixedFinalEnvelope !== undefined && (transactions.length !== 1 || transactions[0].kind !== "atomic")) {
-        throw new LifecyclePlanningError("INVALID_GAS_ENVELOPE", "Fixed final envelope requires one immediate atomic launch with no preceding approvals");
-    }
-    if (metadata.reasons.length > 0) {
-        return { ...planned, simulation: { ...placeholder, confidence: "stateful", reason: metadata.reasons.join("; "), failureCategory: "semantic" }, transactions, totalCalldataBytes: transactions.reduce((total, transaction) => total + (transaction.data.length - 2) / 2, 0) };
-    }
-    const envelope = diagnostic ? undefined : fixedFinalEnvelope;
-    const preparedSimulation = prepareLaunchSimulation({ client, planned, limits: options.limits, fork: options.fork, signal: options.signal }, block, true, envelope, fixedFinalEnvelope?.gasPrice, sizing);
-    try {
-        const execute = diagnostic ? preparedSimulation.measure : (candidate) => preparedSimulation(candidate, envelope);
-        let simulation = await execute(transactions);
-        assertFinalPlan(planned, options.signal);
-        if (mode === "staged") {
-            // Only pressure at the native ceiling can invalidate packing. A smaller
-            // affordability/RPC/account envelope is not evidence for another wallet write.
-            while (!simulation.admitted && simulation.failedTransactionId?.startsWith("prepare:")) {
-                const failedIndex = transactions.findIndex((transaction) => transaction.id === simulation.failedTransactionId);
-                const failedTransaction = transactions[failedIndex];
-                const step = simulation.steps.find((candidate) => candidate.transactionId === simulation.failedTransactionId);
-                const count = failedTransaction?.marketCount ?? 0;
-                if (count <= 1 || step?.gasUsed === undefined || step.gasLimit === undefined || step.gasLimit < limits.executionGasCeiling || step.gasUsed * 100n < limits.executionGasCeiling * 95n)
-                    break;
-                let first = 0;
-                const batchIndex = batches.findIndex((batch) => { const matches = first === failedTransaction?.marketStart; first += batch; return matches; });
-                const left = Math.ceil(count / 2);
-                batches.splice(batchIndex, 1, left, count - left);
-                transactions = orderedTransactions(plan, mode, progress, funding.approvals, batches, ufg);
-                simulation = await execute(transactions);
-                assertFinalPlan(planned, options.signal);
-            }
-            if (!simulation.admitted && simulation.failedTransactionId === "activate")
-                simulation = { ...simulation, reason: `${simulation.reason ?? "Final activation failed"}; final mint/lock/all-buys/public-opening is indivisible and will not be partitioned` };
-        }
-        else if (!diagnostic && !simulation.admitted && !(simulation.capacityConstraint === "compute" && simulation.confidence === "provisional")) {
-            simulation = { ...simulation, reason: `${simulation.reason ?? "Exact atomic plan is not admitted"}; choose staged explicitly only if empty preparation can be partitioned and complete activation fits` };
-        }
-        return { ...planned, simulation, transactions: attachEstimates(transactions, simulation), totalCalldataBytes: transactions.reduce((total, transaction) => total + (transaction.data.length - 2) / 2, 0) };
-    }
-    finally {
-        preparedSimulation.close();
-    }
-}
-async function preflightNextTransaction(options, next, simulation, reviewed) {
-    if (next.gas === undefined || next.gas <= 0n || next.gas >= 1n << 64n || next.gasPrice === undefined || next.gasPrice < 0n ||
-        simulation.executionProof !== "proved" || simulation.protocolFit !== "proved" || !simulation.admitted ||
-        next.estimate === undefined || next.estimate.gasLimit !== next.gas || next.estimate.gasPrice !== next.gasPrice ||
-        simulation.limits.transactionGasCeiling !== undefined && next.gas > simulation.limits.transactionGasCeiling) {
-        throw new LifecyclePlanningError("MISSING_GAS_PROOF", "Next transaction has no current-state exact gas/headroom/fee-envelope proof", simulation);
-    }
-    assertReviewedTransactionUnchanged(options, reviewed, next);
-    const submissionClient = options.submissionClient;
-    assertPlanningActive(options.signal);
-    if (submissionClient === undefined)
-        return { ...next, dependencies: [] };
+    const capacity = deriveLifecycleLaunchCapacity({ plan, predictedToken: identity.predictedToken, ufg, headroomBps: limits.headroomBps }, openingBuys);
+    const mode = progress.canonical.phase === LifecyclePhase.None
+        ? await selectLaunchMode(options.mode, plan, capacity, limits, client, block) : identity.mode;
+    planned = { ...planned, mode, prerequisites: funding.prerequisites, profiles: metadata.profiles, hookDeployments: metadata.hookDeployments };
+    if (metadata.reasons.length > 0)
+        return { ...planned, assessment: { ...placeholder, code: "PROFILE_UNAVAILABLE", failureCategory: "semantic",
+                reason: "The selected launch profile could not be read or is unavailable. Refresh the review before continuing." } };
+    let batches;
     try {
-        if (rpcQuantity(await lifecycleRpc(submissionClient, "eth_chainId"), "submission chain ID") !== simulation.chainId)
-            throw new Error("Active submission RPC chain differs from the reviewed transaction");
-        const estimated = rpcQuantity(await lifecycleRpc(submissionClient, "eth_estimateGas", [{
-                from: next.from, to: next.to, data: next.data, value: toHex(next.value), gas: toHex(next.gas), gasPrice: toHex(next.gasPrice),
-                ...(next.nonce === undefined ? {} : { nonce: toHex(next.nonce) }),
-            }, "latest"]), "submission gas estimate");
-        if (estimated <= 0n || estimated > next.gas)
-            throw new Error("Submission RPC gas estimate exceeds the exact reviewed envelope or is zero");
-        assertPlanningActive(options.signal);
+        batches = mode === "staged" ? await preparationBatches(plan, progress.canonical.preparedMarkets, ufg, limits, client, block) : [];
     }
     catch (failure) {
-        if (failure instanceof Error && failure.name === "AbortError")
+        if (!(failure instanceof LifecyclePlanningError) || failure.code !== "PREPARATION_GAS_LIMIT")
             throw failure;
-        const reason = `Exact next-transaction submission preflight failed: ${lifecycleFailureReason(failure)}`;
-        throw new LifecyclePlanningError("SUBMISSION_PREFLIGHT_FAILED", reason, { ...simulation, transportPreflight: "failed", reason });
+        return { ...planned, assessment: { ...placeholder, code: failure.code, reason: failure.message, failureCategory: "capacity", capacityConstraint: "preparation" } };
     }
-    if (next.admission === undefined)
-        throw new LifecyclePlanningError("MISSING_GAS_PROOF", "Next transaction omitted its exact simulation admission", simulation);
+    const transactions = orderedTransactions(plan, mode, progress, funding.approvals, batches, ufg, capacity);
+    const assessment = await assessLifecycleTransactions({ client, planned, limits: options.limits, signal: options.signal }, transactions, block, undefined, openingBuys, capacity);
+    assertFinalPlan(planned, options.signal);
+    return { ...planned, assessment, transactions: attachEstimates(transactions, assessment), totalCalldataBytes: transactions.reduce((total, transaction) => total + (transaction.data.length - 2) / 2, 0) };
+}
+function finalizeNextTransaction(options, next, reviewed) {
     assertPlanningActive(options.signal);
     assertReviewedTransactionUnchanged(options, reviewed, next);
-    return { ...next, dependencies: [], admission: { ...next.admission, transportPreflight: "passed" } };
+    return { ...next, dependencies: [] };
 }
-/** Recovery observes real canonical receipts/nonces, then proves only unfinished
- * execution; known construction metadata is not recertified through getter mirrors. */
+/** Recovery observes actual canonical receipts, then constructs and budgets only
+ * the next command. No launch transaction is executed during planning. */
 export async function buildNextTransaction(options) {
+    const original = options.planned, matches = observedFields(original);
+    const assertInput = () => {
+        if (options.planned !== original || !matches())
+            throw new LifecyclePlanningError("PLAN_MUTATED", "Stored launch context changed while constructing its next transaction");
+        assertFinalPlan(original, options.signal);
+    };
     const supplied = readReviewedNextTransaction(options.reviewedTransaction);
-    // Snapshot only the reviewed wire fields; caller proofs and commands are never
-    // reused, and final checks compare the mutable input with this one local copy.
+    const walletApproval = supplied?.kind === "approve" || supplied?.kind === "approve-reset";
     const reviewed = supplied === undefined ? undefined : Object.freeze({ id: supplied.id, kind: supplied.kind, chainId: supplied.chainId,
-        from: supplied.from, to: supplied.to, data: supplied.data, value: supplied.value, gas: supplied.gas, gasPrice: supplied.gasPrice, nonce: supplied.nonce });
+        from: supplied.from, to: supplied.to, data: supplied.data, value: supplied.value, ...(walletApproval ? {} : { gas: supplied.gas, gasPrice: supplied.gasPrice }) });
+    const envelope = reviewed === undefined || walletApproval ? undefined : reviewed;
     const result = await withLifecycleReadClient(options.client, async (client) => {
-        const block = await readLifecyclePlanningBlock(client, options.planned.plan, options.planned.account, options.planned.ufg !== undefined);
-        const limitSource = options.limits === undefined ? options.planned.limits : options.limits;
-        if (getKnownLifecycleDeployment({ chainId: options.planned.chainId, orchestrator: options.planned.plan.orchestrator }) !== undefined && typeof limitSource !== "function") {
-            await Promise.all([
-                readLifecycleTokenAtBlock(client, options.planned.plan, block),
-                readLifecycleHeadProgress(client, options.planned.plan, options.planned.account, block),
-                resolveLifecycleLimits({ client, account: options.planned.account, orchestrator: options.planned.plan.orchestrator, block, chainId: options.planned.chainId }, limitSource),
-            ]);
-        }
+        registerLifecycleFinalCheck(client, assertInput);
+        const block = await readLifecyclePlanningBlock(client, original.plan, original.account, original.ufg !== undefined);
+        const limitSource = options.limits === undefined ? original.limits : options.limits;
         const progress = await readLifecycleExecutionProgress({ ...options, client }, block);
-        if (progress.canonical.phase === LifecyclePhase.Active || progress.canonical.phase === LifecyclePhase.Cancelled) {
-            // Only the confirmed canonical terminal phase is terminal; a head-only
-            // Active observation is not, and the confirmation/nonce/receipt gates below
-            // remain in force for every nonterminal case.
+        if (progress.canonical.phase === LifecyclePhase.Active || progress.canonical.phase === LifecyclePhase.Cancelled)
             return undefined;
-        }
         if (!progress.confirmationSafe)
-            throw new LifecyclePlanningError("UNCONFIRMED_STATE", "Wait for confirmed canonical progress and account nonce, including untracked approvals/replacements, before constructing the next transaction");
+            throw new LifecyclePlanningError("UNCONFIRMED_STATE", "Wait for the selected launch confirmation depth before continuing.");
         if (progress.receipts.some((receipt) => receipt.status === "pending" || receipt.status === "unconfirmed"))
-            throw new LifecyclePlanningError("RECEIPT_PENDING", "Wait for canonical receipt confirmations or resolve replacement before requesting another transaction");
+            throw new LifecyclePlanningError("RECEIPT_PENDING", "Wait for the pending transaction to confirm or resolve its replacement.");
         assertPlanningActive(options.signal);
+        const { limits } = await resolveLifecycleLimits({ client, account: original.account, orchestrator: original.plan.orchestrator, block, chainId: original.chainId }, limitSource);
         if (options.action === "cancel") {
             if (progress.canonical.phase === LifecyclePhase.None)
                 throw new LifecyclePlanningError("NOT_STARTED", "An unstarted plan has no launch escrow to cancel");
-            const { planned } = options;
-            assertFinalPlan(planned, options.signal);
+            const planned = { ...original, progress };
             const transaction = planned.ufg !== undefined ? buildUfgCancelTransaction({ plan: planned.plan, preparedMarkets: progress.canonical.preparedMarkets })
                 : { id: "cancel", kind: "cancel", chainId: Number(planned.chainId), from: planned.account, to: planned.plan.orchestrator, data: encodeFunctionData({ abi: launchLifecycleAbi, functionName: "cancelLaunch", args: [planned.plan] }), value: 0n, dependencies: [], postconditions: [{ kind: "launch", phase: "Cancelled", preparedMarkets: progress.canonical.preparedMarkets }] };
-            transaction.nonce = progress.pendingAccountNonce;
             if (reviewed !== undefined && !matchesReviewedNextTransaction(transaction, reviewed))
-                throw new LifecyclePlanningError("REVIEWED_TRANSACTION_MISMATCH", "Reviewed transaction differs from the current canonical cancellation");
-            const simulation = await simulateLaunchTransactions({ client, planned, limits: options.limits === undefined ? planned.limits : options.limits, fork: options.fork, signal: options.signal }, [transaction], block, reviewed);
-            if (!simulation.admitted)
-                throw new LifecyclePlanningError("CANCEL_NOT_ADMITTED", simulation.reason ?? "Cancellation could not be proved against current canonical state", simulation);
-            const next = attachEstimates([transaction], simulation)[0];
-            if (next === undefined)
-                throw new LifecyclePlanningError("MISSING_GAS_PROOF", "Cancellation omitted its exact simulation admission", simulation);
-            return preflightNextTransaction(options, next, simulation, reviewed);
+                throw new LifecyclePlanningError("REVIEWED_TRANSACTION_MISMATCH", "Reviewed transaction differs from the current cancellation");
+            const assessment = await assessLifecycleTransactions({ client, planned, limits: limitSource, signal: options.signal }, [transaction], block, envelope);
+            if (!assessment.ready)
+                throw new LifecyclePlanningError(assessment.code ?? "CANCEL_NOT_READY", assessment.reason ?? "Cancellation could not be prepared. Refresh before continuing.", assessment);
+            return finalizeNextTransaction(options, attachEstimates([transaction], assessment)[0], reviewed);
         }
-        const { planned } = options;
-        assertFinalPlan(planned, options.signal);
         const funding = progress.canonical.phase === LifecyclePhase.None
-            ? await readFunding(client, planned.plan, block, planned.account, planned.ufg !== undefined)
+            ? await readFunding(client, original.plan, block, original.account, original.ufg !== undefined)
             : { prerequisites: [], approvals: [] };
-        const prepared = progress.canonical.preparedMarkets;
-        let batches = [];
-        if (planned.mode === "staged") {
-            let suffixStart = prepared;
-            const prefix = prepared > 0 ? [prepared] : [];
-            if (reviewed?.kind === "prepare") {
-                const span = /^prepare:(\d+):(\d+)$/.exec(reviewed.id);
-                const first = Number(span?.[1]), count = Number(span?.[2]);
-                if (first !== prepared || !Number.isSafeInteger(count) || count <= 0 || first + count > planned.plan.markets.length)
-                    throw new LifecyclePlanningError("REVIEWED_TRANSACTION_MISMATCH", "Reviewed preparation does not start at the canonical unfinished market");
-                prefix.push(count);
-                suffixStart += count;
-            }
-            const suffix = planned.transactions
-                .filter((transaction) => transaction.kind === "prepare" && transaction.marketStart + transaction.marketCount > suffixStart)
-                .map((transaction) => transaction.marketStart + transaction.marketCount - Math.max(transaction.marketStart, suffixStart));
-            if (suffix.length === 0 && suffixStart < planned.plan.markets.length) {
-                const { limits } = await resolveLifecycleLimits({ client, account: planned.account, orchestrator: planned.plan.orchestrator, block, chainId: planned.chainId }, limitSource);
-                const cap = limits.transactionGasCeiling !== undefined && limits.transactionGasCeiling < limits.executionGasCeiling ? limits.transactionGasCeiling : limits.executionGasCeiling;
-                suffix.push(...packPreparationBatches(planned.plan, suffixStart, cap).slice(suffixStart > 0 ? 1 : 0));
+        const planned = { ...original, progress, prerequisites: funding.prerequisites };
+        const capacity = deriveLifecycleLaunchCapacity({ plan: planned.plan, predictedToken: planned.predictedToken, ufg: planned.ufg, headroomBps: limits.headroomBps });
+        if (progress.canonical.phase === LifecyclePhase.None &&
+            await selectLaunchMode(planned.mode, planned.plan, capacity, limits, client, block) !== planned.mode) {
+            throw new LifecyclePlanningError("MODE_REVIEW_REQUIRED", "This launch requires staged execution. Refresh the review before continuing.");
+        }
+        let candidate = funding.approvals[0];
+        if (candidate === undefined) {
+            const prepared = progress.canonical.preparedMarkets;
+            let command;
+            if (progress.canonical.phase === LifecyclePhase.None)
+                command = { kind: planned.mode === "atomic" ? "atomic" : "begin" };
+            else if (prepared < planned.plan.markets.length) {
+                let count;
+                if (reviewed?.kind === "prepare") {
+                    const span = /^prepare:(\d+):(\d+)$/.exec(reviewed.id);
+                    if (Number(span?.[1]) !== prepared)
+                        throw new LifecyclePlanningError("REVIEWED_TRANSACTION_MISMATCH", "Reviewed preparation does not start at the unfinished market");
+                    count = Number(span?.[2]);
+                }
+                else {
+                    const batches = await preparationBatches(planned.plan, prepared, planned.ufg, limits, client, block);
+                    count = batches[prepared > 0 ? 1 : 0];
+                }
+                if (!Number.isSafeInteger(count) || count <= 0 || prepared + count > planned.plan.markets.length)
+                    throw new LifecyclePlanningError("INVALID_PREPARATION_BATCHES", "Next preparation must cover a positive contiguous unfinished market span");
+                command = { kind: "prepare", first: prepared, count };
             }
-            batches = [...prefix, ...suffix];
+            else
+                command = { kind: "activate" };
+            candidate = buildLifecycleCommand(planned.plan, command, planned.ufg === undefined ? undefined : { account: ufgPlanPrincipal(planned.plan), config: planned.ufg.config });
         }
-        const candidate = orderedTransactions(planned.plan, planned.mode, progress, funding.approvals, batches, planned.ufg)[0];
-        if (candidate === undefined)
-            return undefined;
         if (reviewed !== undefined && !matchesReviewedNextTransaction(candidate, reviewed))
-            throw new LifecyclePlanningError("REVIEWED_TRANSACTION_MISMATCH", "Reviewed transaction differs from the current canonical unfinished next step");
-        const observed = planned.simulation.executionProof === "proved" ? planned.simulation.steps.find((step) => step.transactionId === candidate.id && step.success) : undefined;
-        const compute = observed?.computeGasRequired;
-        const sizing = reviewed !== undefined || compute === undefined ? undefined : new Map([[candidate.id, compute]]);
-        const simulation = await simulateLaunchTransactions({ client, planned, limits: limitSource, fork: options.fork, signal: options.signal }, [candidate], block, reviewed, sizing);
+            throw new LifecyclePlanningError("REVIEWED_TRANSACTION_MISMATCH", "Reviewed transaction differs from the current next step");
+        const assessment = await assessLifecycleTransactions({ client, planned, limits: limitSource, signal: options.signal }, [candidate], block, envelope, undefined, capacity);
         assertFinalPlan(planned, options.signal);
-        if (!simulation.admitted)
-            throw new LifecyclePlanningError("PLAN_NOT_ADMITTED", simulation.reason ?? "Next exact launch transaction is not admitted", simulation);
-        const next = attachEstimates([candidate], simulation)[0];
-        return preflightNextTransaction(options, next, simulation, reviewed);
+        if (!assessment.ready)
+            throw new LifecyclePlanningError(assessment.code ?? "PLAN_NOT_READY", assessment.reason ?? "The next launch step could not be prepared. Refresh before continuing.", assessment);
+        return finalizeNextTransaction(options, attachEstimates([candidate], assessment)[0], reviewed);
     });
-    assertFinalPlan(options.planned, options.signal);
+    assertInput();
     if (result !== undefined)
         assertReviewedTransactionUnchanged(options, reviewed, result);
     return result;
 }
-/** Re-simulates only canonical unfinished work with the same submitted receipt
- * evidence and confirmation depth as build-next, never silently dropping context. */
-export async function simulateLaunchPlan(options) {
-    const { client, planned } = options;
-    if (hashLaunchPlan(planned.plan).toLowerCase() !== planned.planHash.toLowerCase() || hashLaunchIdentity(planned.plan).toLowerCase() !== planned.launchId.toLowerCase())
-        throw new LifecyclePlanningError("PLAN_MUTATED", "Stored economic plan no longer matches its commitment");
-    const current = await planLaunch({
-        client, plan: planned.plan, account: planned.account, mode: planned.mode,
-        limits: options.limits === undefined ? planned.limits : options.limits, fork: options.fork,
-        receipts: options.receipts, confirmations: options.confirmations ?? planned.confirmations, signal: options.signal,
-        ufg: planned.ufg, allowTopologyGaps: planned.allowTopologyGaps, allowMissingPermanentTail: planned.allowMissingPermanentTail,
-    });
-    assertPlannedDeploymentBindings(planned, current);
-    return current.simulation;
-}
 //# sourceMappingURL=planner.js.map