@deeeed/metamask-harness 0.47.1 → 0.47.3

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## Unreleased
 
+## 0.47.3 - 2026-09-05
+
+### Fixed
+
+- Select the requested Mobile Perps mode through the first-entry chooser, verify its detail root, and restore the requested market after mode selection changes the navigation stack.
+- Preserve earlier `call` evidence by assigning each invocation a fresh default artifact directory; approval retries still use the explicit directory in the printed next command.
+
+### Changed
+
+- Teach authors to inspect existing state and limit setup mutations to prerequisites required by their proof.
+
+## 0.47.2 - 2026-09-05
+
+### Changed
+
+- Teach recipe and action discovery, bounded setup probes, source-based diagnosis, and honest blocked-proof reporting through version-matched CLI help.
+
+### Fixed
+
+- Flush machine-readable command output before exit so large JSON documents remain complete when piped to another process.
+- Keep `metamask.perps.set_market_favorite` in the current mode while waiting for a temporarily absent favorite control.
+- Preserve the current Mobile Perps mode when `ui.navigate` omits `mode`, including opaque Android navigation.
+- Prefer an exact visible Mobile Perps market row or recently-viewed tile before falling back to search.
+- Preserve Mobile Perps teardown navigation when embedded and fallback bridges use different wording for a missing scrollable target.
+
 ## 0.47.1 - 2026-09-04
 
 ### Fixed

package/adapters/mobile/bridge-runtime/cdp-bridge.cjs

@@ -195,6 +195,7 @@ const NESTED_ROUTE_PARENTS = {
   PerpsPnlHeroCard: 'Perps', PerpsHIP3Debug: 'Perps',
   PerpsSelectModifyAction: 'Perps', PerpsSelectAdjustMarginAction: 'Perps',
   PerpsSelectOrderType: 'Perps', PerpsTradingView: 'Perps',
+  PerpsModeSelection: 'PerpsModals',
   // Predict
   PredictMarketList: 'Predict', PredictMarketDetails: 'Predict',
   PredictActivityDetail: 'Predict',

package/adapters/mobile/bridge-runtime/lib/bridge-errors.cjs

@@ -18,6 +18,10 @@ const BRIDGE_ERROR_CODES = {
   METRO_UNREACHABLE: 'METRO_UNREACHABLE',
 };
 
+const BRIDGE_RESULT_ERROR_CODES = {
+  SCROLLABLE_NOT_FOUND: 'SCROLLABLE_NOT_FOUND',
+};
+
 // Process exit code the bridge returns per failure code so a caller that only
 // sees the child's exit status (no stderr) can still recover the code. Kept
 // clear of exit 1 (unknown/uncoded) and 2 (usage).
@@ -78,6 +82,15 @@ function classifyBridgeErrorMessage(message) {
   return null;
 }
 
+function classifyBridgeResultError(command, result) {
+  if (command !== 'scroll-view' || result?.ok !== false) return null;
+  return /^No scrollable(?: found)? near testID=/u.test(
+    String(result.error ?? ''),
+  )
+    ? BRIDGE_RESULT_ERROR_CODES.SCROLLABLE_NOT_FOUND
+    : null;
+}
+
 // Attach a code to an error at its throw site (source classification).
 function coded(error, code) {
   if (error && typeof error === 'object') error.code = code;
@@ -99,10 +112,12 @@ function parseErrorMarker(text) {
 
 module.exports = {
   BRIDGE_ERROR_CODES,
+  BRIDGE_RESULT_ERROR_CODES,
   EXIT_CODE_BY_ERROR_CODE,
   ERROR_CODE_BY_EXIT_CODE,
   TEACHING_BY_ERROR_CODE,
   classifyBridgeErrorMessage,
+  classifyBridgeResultError,
   coded,
   formatErrorMarker,
   parseErrorMarker,

package/dist/commands/call.js

@@ -1,5 +1,5 @@
 import fs from "node:fs";
-import { createHash } from "node:crypto";
+import { randomUUID } from "node:crypto";
 import path from "node:path";
 import { resolveActionManifest } from "../manifest.js";
 import { importRecipeProtocol } from "../paths.js";
@@ -212,7 +212,7 @@ async function handleCall(argv) {
     }
     return EXIT.validation;
   }
-  const artifactsDir = optionString(options, "artifactsDir") ?? defaultCallArtifactsDir(target, resolvedAction, args);
+  const artifactsDir = optionString(options, "artifactsDir") ?? defaultCallArtifactsDir(target, resolvedAction);
   recordCommandEvidence(artifactsDir);
   const requestedRuntimeOptions = runtimeOptionsFromCli(options);
   const inheritedSource = process.env.FARMSLOT_RECIPE_SOURCE_TRUST || process.env.FARMSLOT_RECIPE_SOURCE_KIND || process.env.FARMSLOT_RECIPE_SOURCE_NAME || process.env.FARMSLOT_RECIPE_SOURCE_DIGEST;
@@ -493,10 +493,9 @@ function renderDefaultsUsed(defaults, stream) {
   const values = Object.entries(defaults).map(([name, value]) => `${out("cmd", name)}=${out("accent", JSON.stringify(value) ?? String(value))}`).join(", ");
   return `${out("label", "Defaults used:")} ${values}`;
 }
-function defaultCallArtifactsDir(target, action, args) {
+function defaultCallArtifactsDir(target, action) {
   const actionStem = action.replace(/[^a-zA-Z0-9._-]/gu, "_");
-  const digest = createHash("sha256").update(JSON.stringify({ action, args })).digest("hex").slice(0, 12);
-  return path.join(target, "temp", "recipe", "calls", `${actionStem}-${digest}`);
+  return path.join(target, "temp", "recipe", "calls", `${actionStem}-${randomUUID()}`);
 }
 function readCallOutput(tracePath) {
   try {

package/dist/mm-harness-cli.js

@@ -830,7 +830,7 @@ for (const command of REAL) {
     if (command.name === "tutorial") {
       process.exit(handleTutorial(rawArgv.slice(1), { harnessVersion: pkgVersion }));
     }
-    process.exit(await withCommandJournal(command.name, rawArgv, () => delegate(rawArgv)));
+    process.exitCode = await withCommandJournal(command.name, rawArgv, () => delegate(rawArgv));
   });
 }
 const HIDDEN = [

package/library/actions/mobile/perps/perps.mjs

@@ -1,5 +1,6 @@
 import { pathToFileURL } from 'node:url';
 import {
+  MOBILE_BRIDGE_RESULT_ERROR_CODES,
   bridgeCommand,
   evalAsync,
   isTargetTransition,
@@ -130,7 +131,7 @@ function withRemainingDeadline(input, requestedDeadline, attemptTimeoutMs) {
   };
 }
 
-async function isModePresent(input, mode, deadline) {
+async function queryModeState(input, mode, deadline) {
   const rootTarget = JSON.stringify({
     testId: MODE_ROOT_TEST_IDS[mode],
     visibility: 'viewport',
@@ -139,6 +140,10 @@ async function isModePresent(input, mode, deadline) {
     testId: MODE_TEST_IDS[mode],
     visibility: 'tree',
   });
+  const choiceTarget = JSON.stringify({
+    testId: `perps-mode-selection-${mode}-option`,
+    visibility: 'viewport',
+  });
   const result = await evalAsync(
     withRemainingDeadline(input, deadline, READ_ATTEMPT_TIMEOUT_MS),
     `(function(){
@@ -148,21 +153,25 @@ async function isModePresent(input, mode, deadline) {
       }
       return Promise.all([
         api.queryUiTarget(${rootTarget}),
-        api.queryUiTarget(${controlTarget})
+        api.queryUiTarget(${controlTarget}),
+        api.queryUiTarget(${choiceTarget})
       ]).then(function(values){
-        return JSON.stringify({ root: values[0], control: values[1] });
+        return JSON.stringify({ root: values[0], control: values[1], choice: values[2] });
       });
     })()`,
   );
   if (result?.unsupported) {
     throw new Error('metamask.perps.ensure_mode requires UI target queries.');
   }
-  return result?.root?.visible === true && result?.control?.present === true;
+  return {
+    present: result?.root?.visible === true && result?.control?.present === true,
+    choiceVisible: result?.choice?.visible === true,
+  };
 }
 
-async function readModePresence(input, mode, deadline) {
+async function readModeState(input, mode, deadline) {
   try {
-    return await isModePresent(input, mode, deadline);
+    return await queryModeState(input, mode, deadline);
   } catch (error) {
     if (!isTargetTransition(error)) throw error;
     return null;
@@ -180,14 +189,15 @@ export async function ensureMode(input) {
     Number(input.node?.timeout_ms ?? 30_000),
   );
   let switched = false;
+  let choiceSelected = false;
 
   while (Date.now() < deadline) {
-    const requestedModePresent = await readModePresence(
+    const requestedState = await readModeState(
       input,
       requestedMode,
       deadline,
     );
-    if (requestedModePresent) {
+    if (requestedState?.present && !requestedState.choiceVisible) {
       return {
         action: input.action,
         mode: requestedMode,
@@ -196,13 +206,23 @@ export async function ensureMode(input) {
       };
     }
     if (Date.now() >= deadline) break;
-    if (requestedModePresent !== null && !switched) {
-      const otherModePresent = await readModePresence(
+    if (requestedState?.choiceVisible && !choiceSelected) {
+      const pressed = await bridgeCommand(withRemainingDeadline(input, deadline), [
+        'press-test-id',
+        `perps-mode-selection-${requestedMode}-option`,
+      ]);
+      if (pressed?.ok === false) {
+        throw new Error(String(pressed.error || 'Perps mode choice press failed.'));
+      }
+      choiceSelected = true;
+      switched = true;
+    } else if (requestedState !== null && !switched) {
+      const otherState = await readModeState(
         input,
         otherMode,
         deadline,
       );
-      if (otherModePresent && Date.now() < deadline) {
+      if (otherState?.present && Date.now() < deadline) {
         // The visible control names the mode it will switch to, not the mode
         // currently selected.
         const pressed = await bridgeCommand(withRemainingDeadline(input, deadline), [
@@ -915,29 +935,50 @@ async function readVisiblePerpsTestIds(input, deadline) {
   return new Set(visible.items.map((item) => String(item.test_id ?? '')));
 }
 
-async function waitForPerpsUiTarget(input, testId, deadline) {
+async function waitForPerpsUiTargets(input, testIds, deadline) {
   let lastTestIds = [];
   while (Date.now() < deadline) {
-    const testIds = await readVisiblePerpsTestIds(input, deadline);
-    if (testIds.has(testId)) return testIds;
-    lastTestIds = [...testIds].filter(Boolean).slice(0, 20);
+    const visibleTestIds = await readVisiblePerpsTestIds(input, deadline);
+    const matchedTestId = testIds.find((testId) =>
+      visibleTestIds.has(testId),
+    );
+    if (matchedTestId) return { matchedTestId, visibleTestIds };
+    lastTestIds = [...visibleTestIds].filter(Boolean).slice(0, 20);
     await sleepBeforeDeadline(deadline, 250);
   }
+  const targetDescription =
+    testIds.length === 1
+      ? `control ${testIds[0]}`
+      : `controls ${testIds.join(' or ')}`;
   throw new Error(
-    `Perps control ${testId} did not become visible before timeout. Observed: ${lastTestIds.join(', ') || 'none'}.`,
+    `Perps ${targetDescription} did not become visible before timeout. Observed: ${lastTestIds.join(', ') || 'none'}.`,
   );
 }
 
+async function waitForPerpsUiTarget(input, testId, deadline) {
+  const { visibleTestIds } = await waitForPerpsUiTargets(
+    input,
+    [testId],
+    deadline,
+  );
+  return visibleTestIds;
+}
+
 async function selectPerpsMarketFromHome(input, symbol, previousRoute) {
   const timeoutMs = Number(input.node?.navigation_timeout_ms ?? 15_000);
   const deadline = deadlineFromTimeout(input, timeoutMs);
   const params = { market: { symbol } };
   const rowTestId = `perps-market-row-item-${symbol}`;
+  const recentlyViewedTestId = `perps-recently-viewed-tile-${symbol}`;
+  const marketTestIds = [rowTestId, recentlyViewedTestId];
   const searchTestId = 'perps-market-list-search-bar';
   let visibleTestIds = await readVisiblePerpsTestIds(input, deadline);
+  let marketTestId = marketTestIds.find((testId) =>
+    visibleTestIds.has(testId),
+  );
   let usedSearch = false;
 
-  if (!visibleTestIds.has(rowTestId)) {
+  if (!marketTestId) {
     if (!visibleTestIds.has(searchTestId)) {
       if (!visibleTestIds.has('perps-home-search-toggle')) {
         throw new Error(
@@ -959,17 +1000,19 @@ async function selectPerpsMarketFromHome(input, symbol, previousRoute) {
       searchTestId,
       symbol,
     ]);
-    visibleTestIds = await waitForPerpsUiTarget(
+    const visibleMarketTarget = await waitForPerpsUiTargets(
       input,
-      rowTestId,
+      marketTestIds,
       deadline,
     );
+    visibleTestIds = visibleMarketTarget.visibleTestIds;
+    marketTestId = visibleMarketTarget.matchedTestId;
     usedSearch = true;
   }
 
   await bridgeCommand(withRemainingDeadline(input, deadline), [
     'press-test-id',
-    rowTestId,
+    marketTestId,
   ]);
   const currentRoute = await waitForRoute(
     withRemainingDeadline(input, deadline),
@@ -983,7 +1026,7 @@ async function selectPerpsMarketFromHome(input, symbol, previousRoute) {
     previousRoute,
     currentRoute,
     verifiedRoute: 'PerpsMarketDetails',
-    visibleMarketSelection: { usedSearch },
+    visibleMarketSelection: { usedSearch, testId: marketTestId },
   };
 }
 
@@ -1033,7 +1076,12 @@ async function navigateFromMarketDetailsToHome(input, previousRoute) {
         backTestId = expectedBackTestId;
         break;
       } catch (error) {
-        if (!/No scrollable near testID=/u.test(String(error))) throw error;
+        if (
+          error?.code !==
+          MOBILE_BRIDGE_RESULT_ERROR_CODES.SCROLLABLE_NOT_FOUND
+        ) {
+          throw error;
+        }
       }
     }
   }
@@ -1079,7 +1127,7 @@ async function navigateFromMarketDetailsToHome(input, previousRoute) {
   };
 }
 
-async function navigatePerps(input) {
+export async function navigatePerps(input) {
   const selected = String(
     input.node?.target ?? input.node?.destination ?? defaultNavigationTarget(input.node),
   ).toLowerCase();
@@ -1789,7 +1837,7 @@ export async function startState(input) {
   const navigation = await applyStateNavigation(stateInput(), config);
   const provider = await ensureProvider(stateInput(), config);
   const network = await ensureNetwork(stateInput(), config);
-  const resolvedNavigation = provider.changed || network.changed
+  let resolvedNavigation = provider.changed || network.changed
     ? await applyStateNavigation(stateInput(), config)
     : navigation;
   const modeInput = stateInput();
@@ -1804,6 +1852,9 @@ export async function startState(input) {
         },
       })
     : { skipped: true };
+  if (marketMode.alreadySelected === false) {
+    resolvedNavigation = await applyStateNavigation(stateInput(), config);
+  }
   const tutorial = await applyTutorialState(stateInput(), config);
   const readyToTrade = await assertReadyToTrade(stateInput(), config);
   const balance = await assertBalance(stateInput(), config);

package/library/actions/mobile/perps/set_market_favorite.mjs

@@ -51,17 +51,6 @@ runAdapter(async (input) => {
       throw new Error(`Visible Perps market ${JSON.stringify(subtitle)} does not match ${market}.`);
     }
     let control = favoriteControl(snapshot);
-    if (!control && nativeNode(snapshot, 'perps-mode-toggle-lite')?.enabled !== false) {
-      try {
-        await session.execute('ui.press', {
-          test_id: 'perps-mode-toggle-lite',
-          timeout_ms: timeoutMs,
-          settle: false,
-        });
-      } catch (error) {
-        if (!/Selector did not match/iu.test(String(error?.message ?? error))) throw error;
-      }
-    }
     const controlDeadline = Date.now() + timeoutMs;
     let lastControls = [];
     while (Date.now() <= controlDeadline && !control) {

package/library/actions/mobile/platform/bridge.mjs

@@ -13,8 +13,10 @@ import { resolveMobileToolPath } from './tool-paths.mjs';
 
 const {
   BRIDGE_ERROR_CODES,
+  BRIDGE_RESULT_ERROR_CODES,
   ERROR_CODE_BY_EXIT_CODE,
   classifyBridgeErrorMessage,
+  classifyBridgeResultError,
   coded,
   parseErrorMarker,
 } = bridgeErrors;
@@ -24,6 +26,7 @@ const { resolvePort } = configModule;
 // Re-exported so the TS adapter classifies on the same code constants without a
 // second import path into the cjs bridge-runtime.
 export const MOBILE_BRIDGE_ERROR_CODES = BRIDGE_ERROR_CODES;
+export const MOBILE_BRIDGE_RESULT_ERROR_CODES = BRIDGE_RESULT_ERROR_CODES;
 
 const execFileAsync = promisify(execFile);
 const ACTION_DEADLINE_FIELD = '_action_deadline_epoch_ms';
@@ -536,9 +539,11 @@ export async function bridgeCommand(input, args) {
   try {
     const parsed = JSON.parse(result.stdout);
     if (parsed && typeof parsed === 'object' && !Array.isArray(parsed) && parsed.ok === false) {
-      throw new Error(
+      const error = new Error(
         `Mobile CDP bridge command reported failure for ${redactBridgeArgs(args).join(' ')}: ${redactBridgeOutput(JSON.stringify(parsed), sensitiveBridgeArgs(args))}`,
       );
+      const code = classifyBridgeResultError(command, parsed);
+      throw code ? coded(error, code) : error;
     }
     return parsed;
   } catch (error) {

package/library/actions/mobile/ui/native-navigation.mjs

@@ -73,7 +73,9 @@ export async function navigateOpaqueMobile(input, destination) {
     artifactsDir: input.context.artifactsDir,
     env,
   };
-  const perpsMode = destination.params?.mode === 'pro' ? 'pro' : 'lite';
+  const perpsMode = ['lite', 'pro'].includes(destination.params?.mode)
+    ? destination.params.mode
+    : undefined;
   const press = (testId) => transport.execute('ui.press', {
     test_id: testId,
     timeout_ms: Number(input.node?.timeout_ms ?? 30_000),
@@ -542,11 +544,16 @@ async function navigatePerpsMarketList({ identifiers, press, wait, back, timeout
   throw new Error(`Opaque Mobile navigation reached ${observed}, but no visible market-list control was available.`);
 }
 
-async function waitForPerpsDestination(identifiers, timeoutMs, press, perpsMode = 'lite') {
+async function waitForPerpsDestination(identifiers, timeoutMs, press, perpsMode) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() <= deadline) {
     const ids = await identifiers();
     if (ids.has(IDS.modeLite) || ids.has(IDS.modePro)) {
+      if (!perpsMode) {
+        throw new Error(
+          'Opaque Mobile navigation requires mode=lite or mode=pro when the product requests a Perps mode choice.',
+        );
+      }
       await press(perpsMode === 'pro' ? IDS.modePro : IDS.modeLite);
       continue;
     }

package/library/actions/mobile/ui/navigate.mjs

@@ -23,8 +23,8 @@ function text(value) {
 function pageRoute(node) {
   const page = text(node?.page);
   if (!page) return undefined;
-  const mode = text(node?.mode)?.toLowerCase() ?? 'lite';
-  if (!['lite', 'pro'].includes(mode)) {
+  const mode = text(node?.mode)?.toLowerCase();
+  if (mode && !['lite', 'pro'].includes(mode)) {
     throw new Error('mobile ui.navigate mode must be lite or pro.');
   }
   if (PAGE_ROUTES[page]) {
@@ -32,13 +32,22 @@ function pageRoute(node) {
     return {
       page,
       ...route,
-      params: page.startsWith('perps') ? { ...route.params, mode } : route.params,
+      params: page.startsWith('perps') && mode
+        ? { ...route.params, mode }
+        : route.params,
     };
   }
   if (page === 'perps-market') {
     const market = text(node.market) ?? text(node.symbol) ?? text(node.params?.market?.symbol);
     if (!market) throw new Error('mobile ui.navigate page=perps-market requires market or symbol.');
-    return { page, route: 'PerpsMarketDetails', params: { market: { symbol: market }, mode } };
+    return {
+      page,
+      route: 'PerpsMarketDetails',
+      params: {
+        market: { symbol: market },
+        ...(mode ? { mode } : {}),
+      },
+    };
   }
   throw new Error('mobile ui.navigate supported page intents: home, perps, perps-market-list, perps-market, swap.');
 }

package/library/manifests/mobile.action-manifest.json

@@ -412,8 +412,7 @@
             "enum": [
               "lite",
               "pro"
-            ],
-            "default": "lite"
+            ]
           },
           "url": {
             "type": "string"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deeeed/metamask-harness",
-  "version": "0.47.1",
+  "version": "0.47.3",
   "type": "module",
   "bin": {
     "mm-harness": "bin/mm-harness"

package/site/assets/help-recipes.json

@@ -26,7 +26,8 @@
       "instruction": "Search the installed recipe and action catalogs, inspect exact schemas, and select the closest recipe before writing anything new.",
       "details": [
         "A bundled recipe, including a Core recipe, is strong composable vocabulary, not authority for every future product version.",
-        "Prefer an existing recipe, then existing actions, then read-only CDP or controller inspection. Add shared vocabulary only after repeated need is proven."
+        "Prefer an existing recipe, then existing actions, then read-only CDP or controller inspection. Add shared vocabulary only after repeated need is proven.",
+        "Before declaring a capability unsupported, inspect both catalogs and the closest recipe's composition. A missing dedicated action may already be composed from UI actions. Read the returned schema before filtering fields; do not treat guessed field names as empty capabilities."
       ],
       "commands": [
         "mm-harness actions --json",
@@ -51,6 +52,7 @@
       "instruction": "Use static call references for unchanged sub-journeys. Keep preparation, action, assertion, evidence, and guaranteed teardown visible as separate nodes with human-facing intent.",
       "details": [
         "Use idempotent ensure actions for required start state and independently assert their postconditions.",
+        "Inspect existing state before creating or cleaning fixtures. Establish only prerequisites required by the claim; a history or display check may already have usable records and need no trade or cleanup. Record the selected records and verify they still satisfy the proof boundary.",
         "Actions translate stable UI, CDP, or controller operations. Recipes compose them. Product code owns business rules."
       ],
       "commands": []
@@ -61,6 +63,7 @@
       "instruction": "Probe each unfamiliar action with call or a tiny action-to-end recipe. Use read-only CDP inspection only when declared actions cannot reveal the needed authoring detail, then consolidate the final proof from manifest-declared actions.",
       "details": [
         "Plan after every structural change and preserve the first failing trace.",
+        "A plan validates structure only. Probe a reused setup boundary against the current build with a short explicit timeout before a full journey; a bundled journey timeout is not a discovery budget.",
         "A CDP observation can help find the current route or selector; it is not final evidence unless the recipe records an allowed action and assertion for that signal."
       ],
       "commands": [
@@ -84,6 +87,7 @@
       "instruction": "Run the complete graph once into an explicit artifact directory, then apply the built-in quality bar before assigning coverage or a verdict.",
       "details": [
         "Coverage: every criterion needs an executable path and assertion; manual, untestable, and environment-dependent gaps stay explicit.",
+        "A blocked required runtime claim is incomplete proof. Passing static checks or closing a checklist cannot make that claim validated or fixed.",
         "Graph: no unconditional pass, generic intent, hidden start state, or opaque node that collapses preparation, action, assertion, evidence, and teardown.",
         "Evidence: inspect the recipe resolution, summary, trace, manifest, logs, and actual visual evidence. A filename or passing node is not visual proof.",
         "Flake risk: wait on observable state instead of sleeping, keep device and runtime identity explicit, and never overwrite a prior run's artifacts.",
@@ -101,6 +105,8 @@
       "instruction": "When a shared recipe fails, reproduce once and classify product regression, recipe drift, fixture/runtime drift, harness defect, or live dependency before changing anything.",
       "details": [
         "The graph and evidence contract can be deterministic while the product, provider, account, or network outcome is not. Honest external rejection remains a valid result, not a reason to seek a green retry.",
+        "Trace the first failure through the exact action source and test the smallest causal explanation before filing or fixing a harness issue. A selector name does not establish its cause. If a proposed fix outgrows the confirmed cause, preserve it separately and return to the minimal fix.",
+        "For blocked runtime proof, retain the target identity, build/app state, and first failing command and error. Reconcile later status snapshots with that evidence; they cannot establish that an earlier device was absent.",
         "For product-version drift, preserve the failed trace, copy the composed recipe into the task, keep working nodes, and repair the smallest owning node against the tested build.",
         "Prove the changed node in isolation, re-plan, then rerun the full task-local recipe and affected callers. Never weaken an assertion or change product code merely to turn stale proof green.",
         "Record the source recipe digest, tested product identity, repair, and fresh evidence. If the defect belongs to reusable harness code or bundled vocabulary, prepare a focused experimental-metamask-harness issue and open it when authorized.",