@t2000/engine 1.14.0 → 1.15.0

package/dist/index.d.ts

@@ -1715,7 +1715,7 @@ declare function bundleShortestTtl(toolUseIds: string[], toolNamesById: Record<s
 declare const REGENERATABLE_READ_TOOLS: ReadonlySet<string>;
 
 /**
- * [Phase 0 → Phase 2 / SPEC 13] Maximum number of writes per atomic bundle.
+ * [Phase 0 → Phase 3a / SPEC 13] Maximum number of writes per atomic bundle.
  *
  * **History.**
  *  - Pre-Phase-0: 5 (F14-fix-2, 2026-05-03 morning).
@@ -1730,31 +1730,35 @@ declare const REGENERATABLE_READ_TOOLS: ReadonlySet<string>;
  *    `composeTx` orchestration loop) but didn't widen the cap. The
  *    primitive is what makes Phase 2's raise to 3 possible — without it,
  *    every additional step is another wallet-fetch race.
- *  - Phase 2 (1.14.0, this version): cap raised to 3. Composition rule
- *    is strict-adjacency: every (step[i], step[i+1]) pair must be in
- *    `VALID_PAIRS`. No new pairs added — Phase 2 is purely the cap raise
- *    + adjacency-loop validation. The chain-mode population loop already
- *    runs over every `(i, i+1)` since 1.13.0, so 3-op atomic bundles
- *    like `withdraw → swap → send` thread two coin handles end-to-end
- *    in one PTB.
- *
- * **Why strict adjacency?** Every consecutive pair must be whitelisted
- * even if the consumer doesn't chain (no `inputCoinFromStep`). This
- * keeps the validator simple and matches the spec's Phase 2 model. The
- * looser DAG-aware variant (where non-chained adjacent steps can be
- * any tool combo) is a Phase 3 follow-up — defer until we see real
- * production flows that need it.
- *
- * **Phase 3+:** `swap_execute → swap_execute` (Demo 1 unlock) + DAG-aware
- * validator + cap raise to 4. SPEC 13 §"Phase 3" / §"Phase 5" tracks
- * these. Don't pre-emptively raise this constant past 3 without those
- * landing.
+ *  - Phase 2 (1.14.0): cap raised to 3. Composition rule was strict-
+ *    adjacency: every (step[i], step[i+1]) pair must be in `VALID_PAIRS`.
+ *    Strict adjacency rejected DAG shapes (`swap → save → send` —
+ *    last pair `save→send` not in whitelist even though step 3 doesn't
+ *    chain from step 2; it pulls a fresh wallet coin).
+ *  - **Phase 3a (1.15.0, this version): cap raised to 4. Composition rule
+ *    relaxed to DAG-aware: only pairs that actually chain via
+ *    `inputCoinFromStep` need whitelist checking. Standalone steps
+ *    interleaved between chained steps run wallet-mode independently
+ *    inside the same atomic PTB.** This unlocks Demo 1 ("swap 10% to
+ *    SUI, save 50% as USDsui, send $100 to Mom" — 4-op DAG with one
+ *    chain at step 1→2, three standalone wallet-mode steps).
+ *
+ * **DAG-aware semantics.** Pre-3a: every adjacent pair gates the entire
+ * bundle. Phase 3a+: each (i, i+1) pair contributes IF a chain is wired
+ * (via `shouldChainCoin`). Non-chained pairs are independent — they
+ * each pre-fetch their own coin from the wallet inside the PTB. Atomic
+ * settlement at the PTB level holds either way.
+ *
+ * **Phase 3b (deferred):** `swap_execute → swap_execute` whitelist add
+ * for explicit multi-hop swap chains (rare; flag-gated when shipped).
+ * **Phase 5+:** cap > 4 once production telemetry confirms zero edge-
+ * case revert rate at cap=4.
  *
  * Hosts importing this constant for system-prompt construction get the
  * current cap automatically. Bumping the cap is a one-line change here
  * that propagates to prompts via the import.
  */
-declare const MAX_BUNDLE_OPS = 3;
+declare const MAX_BUNDLE_OPS = 4;
 /**
  * [Phase 0 / SPEC 13] Whitelisted (producer, consumer) pairs for atomic
  * bundling. Every key has the shape `${producer}->${consumer}`. Bundles

package/dist/index.js

@@ -6737,7 +6737,7 @@ var REGENERATABLE_READ_TOOLS = /* @__PURE__ */ new Set([
 ]);
 
 // src/compose-bundle.ts
-var MAX_BUNDLE_OPS = 3;
+var MAX_BUNDLE_OPS = 4;
 var VALID_PAIRS = /* @__PURE__ */ new Set([
   "swap_execute->send_transfer",
   "swap_execute->save_deposit",
@@ -7885,7 +7885,7 @@ ${recipeCtx}`;
       }
       if (guardPassedWrites.length > MAX_BUNDLE_OPS) {
         const cappedError = {
-          error: `Atomic bundles are capped at ${MAX_BUNDLE_OPS} ops in Phase 0. You attempted ${guardPassedWrites.length}. Execute these as ${guardPassedWrites.length} sequential single-write transactions: tell the user "I'll do this in ${guardPassedWrites.length} steps", then emit only the FIRST write. After it lands and the user confirms each step, emit the next.`,
+          error: `Atomic bundles are capped at ${MAX_BUNDLE_OPS} ops. You attempted ${guardPassedWrites.length}. Execute these as ${guardPassedWrites.length} sequential single-write transactions: tell the user "I'll do this in ${guardPassedWrites.length} steps", then emit only the FIRST write. After it lands and the user confirms each step, emit the next.`,
           _gate: "max_bundle_ops"
         };
         for (const write of guardPassedWrites) {
@@ -7916,50 +7916,6 @@ ${recipeCtx}`;
         const turnIndex = this.messages.filter((m) => m.role === "assistant").length;
         this.turnPaused = true;
         if (allBundleable) {
-          if (guardPassedWrites.length >= 2) {
-            let badPair = null;
-            for (let i = 0; i < guardPassedWrites.length - 1; i++) {
-              const producer = guardPassedWrites[i].call.name;
-              const consumer = guardPassedWrites[i + 1].call.name;
-              const check = checkValidPair(producer, consumer);
-              if (!check.ok) {
-                badPair = check;
-                break;
-              }
-            }
-            if (badPair !== null) {
-              const N = guardPassedWrites.length;
-              const stepsPhrase = N === 2 ? "two steps" : `${N} steps`;
-              const pairError = {
-                error: `Bundle pair '${badPair.pair}' is not in the chaining whitelist. Whitelisted pairs: ${[...VALID_PAIRS].join(", ")}. Run these ${N} writes sequentially: tell the user "I'll do this in ${stepsPhrase}", emit only the first write, then the next after it lands and confirms.`,
-                _gate: "pair_not_whitelisted"
-              };
-              for (const write of guardPassedWrites) {
-                yield {
-                  type: "tool_result",
-                  toolName: write.call.name,
-                  toolUseId: write.call.id,
-                  result: pairError,
-                  isError: true
-                };
-                toolResultBlocks.push({
-                  type: "tool_result",
-                  toolUseId: write.call.id,
-                  content: JSON.stringify(pairError),
-                  isError: true
-                });
-              }
-              this.turnPaused = false;
-              this.messages.push({ role: "assistant", content: acc.assistantBlocks });
-              this.messages.push({ role: "user", content: toolResultBlocks });
-              getTelemetrySink().counter("engine.turn_outcome", {
-                entry: freshPrompt !== null ? "submit" : "resume",
-                outcome: "pair_not_whitelisted_continue",
-                pair: badPair.pair
-              });
-              continue;
-            }
-          }
           const completedResults = toolResultBlocks.map((b) => ({
             toolUseId: b.toolUseId,
             content: b.content,