@t2000/engine 1.15.1 → 1.16.0

package/dist/index.d.ts

@@ -1032,26 +1032,42 @@ interface PendingAction {
     steps?: PendingActionStep[];
     /**
      * [SPEC 7 v0.3 Quote-Refresh] Milliseconds since the upstream read tools
-     * that fed this bundle's composition completed. Engine stamps at emit
+     * that fed this action's composition completed. Engine stamps at emit
      * time using `Date.now() - min(tool_result.timestamp)` across the listed
      * `regenerateInput.toolUseIds`. Host renders as a "QUOTE Ns OLD" badge in
-     * the PermissionCard header. Only set on bundled `pending_action`s.
+     * the PermissionCard header.
+     *
+     * **[SPEC 15 v0.7 follow-up — 2026-05-04]** Now also stamped on
+     * single-write confirm-tier `pending_action`s when same-turn
+     * regeneratable reads contributed (e.g. a confirm-tier
+     * `swap_execute` whose Cetus quote is referenced via the prior
+     * `swap_quote` read). Pre-v0.7 this was bundle-only.
      */
     quoteAge?: number;
     /**
-     * [SPEC 7 v0.3 Quote-Refresh] True when the bundle was composed from
+     * [SPEC 7 v0.3 Quote-Refresh] True when the action was composed from
      * re-runnable read tools (`swap_quote`, `rates_info`, `balance_check`,
      * `portfolio_analysis`). False when amounts came from user-provided
-     * inputs that don't depend on upstream quotes. Single-write
-     * `pending_action`s set this to `false` (regenerate is N≥2 only).
+     * inputs that don't depend on upstream quotes.
+     *
+     * **[SPEC 15 v0.7 follow-up — 2026-05-04]** Now populated for
+     * single-write confirm-tier actions too — pre-v0.7 single-writes
+     * always emitted `false` because the regenerate path was N≥2 only.
+     * Closing that gap surfaced the Refresh-quote affordance for the
+     * single-write confirm-tier scenario (e.g. $50 swap_execute).
      */
     canRegenerate?: boolean;
     /**
      * [SPEC 7 v0.3 Quote-Refresh] Engine-internal payload listing which
      * upstream read `tool_use` ids to re-fire when the user taps REGENERATE.
      * Host echoes this back via `POST /api/engine/regenerate`; engine re-runs
-     * each tool with the same input (no LLM call), rebuilds the bundle, and
-     * emits a fresh `pending_action` with new per-step `attemptId`s.
+     * each tool with the same input (no LLM call), rebuilds the action, and
+     * emits a fresh `pending_action` with a fresh `attemptId`.
+     *
+     * **[SPEC 15 v0.7 follow-up — 2026-05-04]** Populated for both
+     * bundle (N≥2) and single-write (N=1) shapes; the engine's
+     * `regenerateBundle()` rebuild branches on `action.steps?.length`
+     * to pick the right composition path.
      */
     regenerateInput?: {
         toolUseIds: string[];
@@ -1906,15 +1922,17 @@ type RegenerateResult = RegenerateSuccess | RegenerateFailure;
  * store after a successful regenerate.
  *
  * **Failure modes.**
- *  - `pending_action_not_found` — the action isn't a bundle (no
- *    `steps`, or fewer than 2 steps). Single-write actions can't be
- *    regenerated by design.
+ *  - `pending_action_not_found` — reserved for host-side mismatches
+ *    (session expired, attemptId mismatch). The engine itself never
+ *    returns this from `regenerateBundle`; the route surfaces it
+ *    pre-call. (Pre-v0.7 it also fired here for single-write
+ *    actions; lifted as part of single-write regenerate support.)
  *  - `cannot_regenerate` — the action's `canRegenerate` flag is
  *    false, OR no contributing read tool_use_ids could be located in
  *    session history.
- *  - `engine_error` — a tool re-execution threw, OR bundle
- *    composition rejected (defensive — should not happen if the
- *    original bundle was valid).
+ *  - `engine_error` — a tool re-execution threw, OR action
+ *    rebuild rejected (defensive — should not happen if the
+ *    original action was valid).
  *
  * Errors in tool re-execution short-circuit the whole regenerate
  * (bundle composition would inherit a broken read result). The host

package/dist/index.js

@@ -6799,6 +6799,18 @@ function shouldChainCoin(producer, consumer) {
   if (!out || !inA) return false;
   return out === inA;
 }
+function computeRegenerateFields(readResults) {
+  const regenerateToolUseIds = readResults.filter((r) => REGENERATABLE_READ_TOOLS.has(r.toolName)).map((r) => r.toolUseId);
+  const canRegenerate = regenerateToolUseIds.length > 0;
+  let quoteAge;
+  if (canRegenerate) {
+    const stalest = Math.min(
+      ...readResults.filter((r) => REGENERATABLE_READ_TOOLS.has(r.toolName)).map((r) => r.timestamp)
+    );
+    quoteAge = Math.max(0, Date.now() - stalest);
+  }
+  return { canRegenerate, regenerateToolUseIds, quoteAge };
+}
 function composeBundleFromToolResults(input) {
   if (input.pendingWrites.length < 2) {
     throw new Error(
@@ -6837,15 +6849,7 @@ function composeBundleFromToolResults(input) {
       });
     }
   }
-  const regenerateToolUseIds = input.readResults.filter((r) => REGENERATABLE_READ_TOOLS.has(r.toolName)).map((r) => r.toolUseId);
-  const canRegenerate = regenerateToolUseIds.length > 0;
-  let quoteAge;
-  if (regenerateToolUseIds.length > 0) {
-    const stalest = Math.min(
-      ...input.readResults.filter((r) => REGENERATABLE_READ_TOOLS.has(r.toolName)).map((r) => r.timestamp)
-    );
-    quoteAge = Math.max(0, Date.now() - stalest);
-  }
+  const { canRegenerate, regenerateToolUseIds, quoteAge } = computeRegenerateFields(input.readResults);
   const allGuardInjections = [];
   if (input.guardInjectionsByCallId) {
     for (const call of input.pendingWrites) {
@@ -7978,6 +7982,7 @@ ${recipeCtx}`;
         const writeGuardInjections = guardInjectionsByCallId[pendingWrite.call.id];
         const modifiableFields = getModifiableFields(pendingWrite.call.name);
         const attemptId = randomUUID();
+        const singleWriteRegen = computeRegenerateFields(turnReadToolResults);
         yield {
           type: "pending_action",
           action: {
@@ -7994,7 +7999,12 @@ ${recipeCtx}`;
             ...writeGuardInjections?.length ? { guardInjections: writeGuardInjections } : {},
             ...modifiableFields?.length ? { modifiableFields } : {},
             turnIndex,
-            attemptId
+            attemptId,
+            ...singleWriteRegen.canRegenerate ? {
+              canRegenerate: true,
+              regenerateInput: { toolUseIds: singleWriteRegen.regenerateToolUseIds },
+              ...singleWriteRegen.quoteAge !== void 0 ? { quoteAge: singleWriteRegen.quoteAge } : {}
+            } : {}
           }
         };
         recordTurnOutcome("pending_action_single");
@@ -8222,13 +8232,6 @@ function harnessShapeForEffort(effort) {
   }
 }
 async function regenerateBundle(engine, action) {
-  if (!action.steps || action.steps.length < 2) {
-    return {
-      success: false,
-      reason: "pending_action_not_found",
-      message: "Action is not a multi-step bundle"
-    };
-  }
   if (action.canRegenerate !== true) {
     return {
       success: false,
@@ -8342,11 +8345,6 @@ async function regenerateBundle(engine, action) {
     { role: "user", content: synthUserBlocks }
   ];
   engine.loadMessages([...messages, ...synthMessages]);
-  const pendingWrites = action.steps.map((step) => ({
-    id: step.toolUseId,
-    name: step.toolName,
-    input: step.input
-  }));
   const readResults = newReads.map((r) => ({
     toolUseId: r.toolUseId,
     toolName: r.toolName,
@@ -8355,20 +8353,61 @@ async function regenerateBundle(engine, action) {
   const assistantContent = action.assistantContent ?? [];
   const completedResults = action.completedResults ?? [];
   let newPendingAction;
-  try {
-    newPendingAction = composeBundleFromToolResults({
-      pendingWrites,
-      tools,
-      readResults,
+  if (action.steps && action.steps.length >= 2) {
+    const pendingWrites = action.steps.map((step) => ({
+      id: step.toolUseId,
+      name: step.toolName,
+      input: step.input
+    }));
+    try {
+      newPendingAction = composeBundleFromToolResults({
+        pendingWrites,
+        tools,
+        readResults,
+        assistantContent,
+        completedResults,
+        turnIndex: action.turnIndex
+      });
+    } catch (err) {
+      return {
+        success: false,
+        reason: "engine_error",
+        message: err instanceof Error ? err.message : "Bundle rebuild failed"
+      };
+    }
+  } else {
+    const tool = findTool(tools, action.toolName);
+    if (!tool) {
+      return {
+        success: false,
+        reason: "engine_error",
+        message: `Unknown tool '${action.toolName}' in single-write rebuild`
+      };
+    }
+    const call = {
+      id: action.toolUseId,
+      name: action.toolName,
+      input: action.input
+    };
+    const description = describeAction(tool, call);
+    const modifiableFields = getModifiableFields(action.toolName);
+    const { canRegenerate, regenerateToolUseIds, quoteAge } = computeRegenerateFields(readResults);
+    newPendingAction = {
+      toolName: action.toolName,
+      toolUseId: action.toolUseId,
+      input: action.input,
+      description,
       assistantContent,
       completedResults,
-      turnIndex: action.turnIndex
-    });
-  } catch (err) {
-    return {
-      success: false,
-      reason: "engine_error",
-      message: err instanceof Error ? err.message : "Bundle rebuild failed"
+      ...action.guardInjections?.length ? { guardInjections: action.guardInjections } : {},
+      ...modifiableFields?.length ? { modifiableFields } : {},
+      turnIndex: action.turnIndex,
+      attemptId: randomUUID(),
+      ...canRegenerate ? {
+        canRegenerate: true,
+        regenerateInput: { toolUseIds: regenerateToolUseIds },
+        ...quoteAge !== void 0 ? { quoteAge } : {}
+      } : {}
     };
   }
   return { success: true, newPendingAction, timelineEvents };