@deeeed/metamask-harness 0.58.0 → 0.60.0

package/dist/commands/launch/index.js

@@ -3,7 +3,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { color, colorHumanMessage } from "../../cli-color.js";
 import { handleHarness } from "../../harness.js";
-import { recipeRuntimePath, runnerDir } from "../../paths.js";
+import { recipeRuntimePath, runnerDir, walletFixturePath } from "../../paths.js";
 import { getAdapterSurface } from "../../adapters/surface.js";
 import {
   ADAPTER_DETECT_NEXT,
@@ -35,6 +35,15 @@ import { launchMobile } from "./mobile.js";
 import { applyDeviceTargeting } from "../device-target.js";
 import { acquireCheckoutLock } from "../../checkout-lock.js";
 import { JsonStreamWriter } from "../../json-stream.js";
+import {
+  FeatureFlagSpecError,
+  fixtureFeatureFlags,
+  parseRemoteFlagSpec,
+  remoteFlagRequestFor,
+  sameFeatureFlags,
+  toRemoteFlagSpec
+} from "../../feature-flags.js";
+import { readExtensionPinnedFlags } from "../../adapters/extension/feature-flags.js";
 import { ensureExtensionConsoleCapture } from "../../adapters/extension/console-capture.js";
 import { extensionProductConfigBlock } from "../../adapters/extension/product-config.js";
 import {
@@ -178,6 +187,25 @@ async function handleLaunchLocked(argv, stream) {
     );
   }
   const displayMode = requestedSurface ?? legacySurface ?? "fullscreen";
+  const remoteFlagSpec = str(options, "remoteFlag");
+  if (remoteFlagSpec !== void 0 && adapter === "extension" && wantWatch) {
+    return launchUsage(
+      jsonOutput,
+      stream,
+      "--remote-flag cannot be applied with --watch: the watcher never re-creates the dist snapshot that carries the pin.",
+      `mm-harness launch --adapter extension --remote-flag ${remoteFlagSpec} --target ${shellQuote(target)}`
+    );
+  }
+  let remoteFlagRequest;
+  try {
+    remoteFlagRequest = remoteFlagRequestFor({
+      ...fixtureFeatureFlags(walletFixturePath(target)),
+      ...remoteFlagSpec === void 0 ? {} : parseRemoteFlagSpec(remoteFlagSpec)
+    });
+  } catch (error) {
+    if (!(error instanceof FeatureFlagSpecError)) throw error;
+    return launchUsage(jsonOutput, stream, error.message, error.userAction);
+  }
   for (const portFlag of ["cdpPort", "watcherPort"]) {
     const value = str(options, portFlag);
     if (value !== void 0 && !/^\d+$/u.test(value)) {
@@ -286,10 +314,23 @@ async function handleLaunchLocked(argv, stream) {
     machine,
     displayMode,
     false,
-    wantClearMetro
+    wantClearMetro,
+    remoteFlagRequest
   );
   if (attempt.status === 0) {
-    return await finishLaunch(jsonOutput, machine, stream, adapter, mobileTarget, tier, displayMode, target, state, wantWatch, wantVerify);
+    return await settleLaunch(jsonOutput, machine, stream, adapter, mobileTarget, tier, displayMode, target, state, wantWatch, wantVerify, remoteFlagRequest, true, attempt.remoteFeatureFlags);
+  }
+  if (adapter === "extension" && attempt.output.includes("REMOTE_FLAG_NOT_PINNABLE:")) {
+    return launchFail(jsonOutput, stream, adapter, mobileTarget, tier, state, target, {
+      code: "REMOTE_FLAG_NOT_PINNABLE",
+      message: `a verified release artifact cannot carry a remote feature-flag pin (${remoteFlagRequest?.spec ?? ""}); its manifest is signed evidence and is never rewritten. Validate the artifact as shipped (drop --remote-flag and the fixture's remoteFeatureFlags) or validate the variant on a source build.`,
+      recoverable: false,
+      // The next step must leave the artifact alone: a --build here would replace
+      // the artifact under validation with a source build.
+      userAction: Object.keys(fixtureFeatureFlags(walletFixturePath(target))).length > 0 ? `remove remoteFeatureFlags from ${shellQuote(walletFixturePath(target))}, then: mm-harness launch --adapter extension --target ${shellQuote(target)}` : `mm-harness launch --adapter extension --target ${shellQuote(target)}`,
+      exitCode: EXIT.infra,
+      originalError: attempt.output.trim() || void 0
+    });
   }
   if (adapter === "extension" && extensionProductConfigMissing(attempt.output)) {
     const block = extensionProductConfigBlock(target);
@@ -352,10 +393,10 @@ async function handleLaunchLocked(argv, stream) {
     const recoveryCode2 = "chrome.relaunched";
     state.attemptedRecoveries.push(recoveryCode2);
     stream.phase("recover");
-    const rebuildAttempt = await executeComposition(adapter, mobileTarget, "build", wantWatch, target, machine, displayMode);
+    const rebuildAttempt = await executeComposition(adapter, mobileTarget, "build", wantWatch, target, machine, displayMode, false, false, remoteFlagRequest);
     if (rebuildAttempt.status === 0) {
       state.recovered.push(recoveryCode2);
-      return await finishLaunch(jsonOutput, machine, stream, adapter, mobileTarget, tier, displayMode, target, state, wantWatch, wantVerify);
+      return await settleLaunch(jsonOutput, machine, stream, adapter, mobileTarget, tier, displayMode, target, state, wantWatch, wantVerify, remoteFlagRequest, true, rebuildAttempt.remoteFeatureFlags);
     }
     return launchFail(jsonOutput, stream, adapter, mobileTarget, tier, state, target, {
       code: "EXTENSION_RELAUNCH_FAILED",
@@ -434,11 +475,13 @@ async function handleLaunchLocked(argv, stream) {
     target,
     machine,
     displayMode,
-    restartMobileApp
+    restartMobileApp,
+    false,
+    remoteFlagRequest
   );
   if (attempt.status === 0) {
     state.recovered.push(recoveryCode);
-    return await finishLaunch(jsonOutput, machine, stream, adapter, mobileTarget, tier, displayMode, target, state, wantWatch, wantVerify);
+    return await settleLaunch(jsonOutput, machine, stream, adapter, mobileTarget, tier, displayMode, target, state, wantWatch, wantVerify, remoteFlagRequest, true, attempt.remoteFeatureFlags);
   }
   return launchFail(jsonOutput, stream, adapter, mobileTarget, tier, state, target, {
     code: "SAME_RECOVERY_TWICE",
@@ -560,7 +603,39 @@ function nativeInputsChanged(target, adapter) {
     return false;
   }
 }
-async function executeComposition(adapter, mobileTarget, tier, wantWatch, target, json, displayMode = "fullscreen", restartMobileApp = false, clearMobileMetro = false) {
+function verifyExtensionPin(target, requested) {
+  const pinned = readExtensionPinnedFlags(target);
+  if (pinned.error) {
+    return {
+      ok: false,
+      flags: {},
+      code: "RUNTIME_MANIFEST_UNREADABLE",
+      message: `the launched dist snapshot manifest could not be read (${pinned.sourcePath ?? "unknown path"}): ${pinned.error}`
+    };
+  }
+  if (pinned.overrides !== null && pinned.pinned === null) {
+    return {
+      ok: false,
+      flags: {},
+      code: "REMOTE_FLAG_NOT_APPLIED",
+      message: `the launched dist snapshot manifest (${pinned.sourcePath ?? "unknown path"}) carries no harness pin record; it was not written by this launch.`
+    };
+  }
+  const actual = pinned.pinned ?? {};
+  if (!sameFeatureFlags(actual, requested)) {
+    const mismatched = [.../* @__PURE__ */ new Set([...Object.keys(requested), ...Object.keys(actual)])].filter(
+      (key) => JSON.stringify(actual[key]) !== JSON.stringify(requested[key])
+    );
+    return {
+      ok: false,
+      flags: {},
+      code: "REMOTE_FLAG_NOT_APPLIED",
+      message: `the remote feature-flag pin ${toRemoteFlagSpec(requested) || "(none)"} does not match the launched snapshot manifest: ` + mismatched.map((key) => `${key} expected ${JSON.stringify(requested[key])}, got ${JSON.stringify(actual[key])}`).join("; ")
+    };
+  }
+  return { ok: true, flags: actual, message: "" };
+}
+async function executeComposition(adapter, mobileTarget, tier, wantWatch, target, json, displayMode = "fullscreen", restartMobileApp = false, clearMobileMetro = false, remoteFlagRequest) {
   if (adapter === "mobile") {
     return launchMobile(
       target,
@@ -568,12 +643,44 @@ async function executeComposition(adapter, mobileTarget, tier, wantWatch, target
       tier,
       json,
       restartMobileApp,
-      clearMobileMetro
+      clearMobileMetro,
+      remoteFlagRequest?.flags
     );
   }
-  return launchExtension(target, tier, wantWatch, displayMode);
+  return launchExtension(target, tier, wantWatch, displayMode, remoteFlagRequest);
 }
-async function finishLaunch(jsonOutput, machine, stream, adapter, mobileTarget, tier, displayMode, target, state, wantWatch, wantVerify, sidepanelRecoveryAllowed = true) {
+async function settleLaunch(jsonOutput, machine, stream, adapter, mobileTarget, tier, displayMode, target, state, wantWatch, wantVerify, remoteFlagRequest, sidepanelRecoveryAllowed = true, mobileProvenFlags) {
+  const requested = remoteFlagRequest?.flags ?? {};
+  const pinned = adapter !== "extension" ? { ok: true, flags: mobileProvenFlags === void 0 ? requested : mobileProvenFlags, message: "" } : wantWatch ? { ok: true, flags: readExtensionPinnedFlags(target).pinned, message: "" } : verifyExtensionPin(target, requested);
+  if (!pinned.ok) {
+    const spec = remoteFlagRequest?.spec;
+    return launchFail(jsonOutput, stream, adapter, mobileTarget, tier, state, target, {
+      code: pinned.code ?? "REMOTE_FLAG_NOT_APPLIED",
+      message: pinned.message,
+      recoverable: false,
+      // A rebuild re-creates the snapshot; the flag is repeated only when one was asked for.
+      userAction: `mm-harness launch --adapter extension --build${spec ? ` --remote-flag ${spec}` : ""} --target ${shellQuote(target)}`,
+      exitCode: EXIT.runtime
+    });
+  }
+  return finishLaunch(
+    jsonOutput,
+    machine,
+    stream,
+    adapter,
+    mobileTarget,
+    tier,
+    displayMode,
+    target,
+    state,
+    wantWatch,
+    wantVerify,
+    sidepanelRecoveryAllowed,
+    remoteFlagRequest,
+    pinned.flags
+  );
+}
+async function finishLaunch(jsonOutput, machine, stream, adapter, mobileTarget, tier, displayMode, target, state, wantWatch, wantVerify, sidepanelRecoveryAllowed = true, remoteFlagRequest, remoteFlags = {}) {
   if (adapter === "extension" && displayMode === "fullscreen") {
     const sidepanelSh = path.join(runnerDir, "adapters/extension/sidepanel-toggle.sh");
     const sidepanelArgs = ["close"];
@@ -605,10 +712,10 @@ async function finishLaunch(jsonOutput, machine, stream, adapter, mobileTarget,
       if (sidepanelRecoveryAllowed && tier === "quick" && extensionRuntimeBlocked(sidepanel.output) && !state.attemptedRecoveries.includes(recoveryCode)) {
         state.attemptedRecoveries.push(recoveryCode);
         stream.phase("recover");
-        const rebuildAttempt = await executeComposition(adapter, mobileTarget, "build", wantWatch, target, machine, displayMode);
+        const rebuildAttempt = await executeComposition(adapter, mobileTarget, "build", wantWatch, target, machine, displayMode, false, false, remoteFlagRequest);
         if (rebuildAttempt.status === 0) {
           state.recovered.push(recoveryCode);
-          return await finishLaunch(
+          return await settleLaunch(
             jsonOutput,
             machine,
             stream,
@@ -620,6 +727,7 @@ async function finishLaunch(jsonOutput, machine, stream, adapter, mobileTarget,
             state,
             wantWatch,
             wantVerify,
+            remoteFlagRequest,
             false
           );
         }
@@ -668,14 +776,15 @@ async function finishLaunch(jsonOutput, machine, stream, adapter, mobileTarget,
         tier,
         recovered: state.recovered,
         mutations: state.mutations,
-        metro: metroLaunchEvidence(adapter, target)
+        metro: metroLaunchEvidence(adapter, target),
+        remoteFeatureFlags: remoteFlags
       });
     }
     return exitCode;
   }
-  return launchPass(jsonOutput, stream, adapter, mobileTarget, tier, displayMode, target, state);
+  return launchPass(jsonOutput, stream, adapter, mobileTarget, tier, displayMode, target, state, remoteFlags);
 }
-function launchPass(json, stream, adapter, mobileTarget, tier, displayMode, target, state) {
+function launchPass(json, stream, adapter, mobileTarget, tier, displayMode, target, state, remoteFlags = {}) {
   if (stream.enabled) {
     for (const mutation of state.mutations) stream.mutation(mutation);
     for (const recovery of state.recovered) stream.recovery(recovery);
@@ -685,7 +794,8 @@ function launchPass(json, stream, adapter, mobileTarget, tier, displayMode, targ
       tier,
       recovered: state.recovered,
       mutations: state.mutations,
-      metro: metroLaunchEvidence(adapter, target)
+      metro: metroLaunchEvidence(adapter, target),
+      remoteFeatureFlags: remoteFlags
     });
   } else if (json) {
     console.log(
@@ -701,6 +811,7 @@ function launchPass(json, stream, adapter, mobileTarget, tier, displayMode, targ
           recovered: state.recovered,
           mutations: state.mutations,
           metro: metroLaunchEvidence(adapter, target),
+          remoteFeatureFlags: remoteFlags,
           exitCode: EXIT.ok
         },
         null,

package/dist/commands/launch/mobile.js

@@ -4,9 +4,11 @@ import {
   recordMobileSourceBaseline
 } from "../../adapters/mobile/source-freshness.js";
 import { ensureHarnessFresh } from "../../adapters/harness-freshness.js";
+import { pinMobileFeatureFlags } from "../../adapters/mobile/feature-flags.js";
+import { toRemoteFlagSpec } from "../../feature-flags.js";
 import { clearMobileReleaseArtifactState } from "../../adapters/mobile/release-artifact-state.js";
 import { EXIT } from "../shared.js";
-async function launchMobile(target, mobileTarget, tier, json, restartApp = false, clearMetro = false) {
+async function launchMobile(target, mobileTarget, tier, json, restartApp = false, clearMetro = false, remoteFlags) {
   clearMobileReleaseArtifactState(target);
   await ensureHarnessFresh(target, "mobile");
   const platform = mobileTarget ?? "ios";
@@ -22,13 +24,35 @@ async function launchMobile(target, mobileTarget, tier, json, restartApp = false
     clearMetro
   });
   if (result.status !== 0) return result;
+  const flags = remoteFlags ?? {};
+  const pin = await pinMobileFeatureFlags(target, flags);
+  let provenFlags = flags;
+  if (!pin.ok && !remoteFlags && pin.error) {
+    provenFlags = null;
+    if (!json) process.stderr.write(`WARN: remote feature-flag overrides were not cleared: ${pin.error}
+`);
+  } else if (!pin.ok) {
+    const detail = pin.error ?? `did not read back: ${pin.mismatched.join(", ")} (got ${JSON.stringify(
+      Object.fromEntries(pin.mismatched.map((key) => [key, pin.effective[key] ?? pin.overrides[key]]))
+    )})`;
+    const message = `REMOTE_FLAG_NOT_APPLIED: remote feature flags ${toRemoteFlagSpec(flags) || "(none: clearing overrides)"} ${detail}
+  Next: confirm the app is running with the harness bridge, then re-run mm-harness launch`;
+    if (!json) process.stderr.write(`${message}
+`);
+    return { status: EXIT.runtime, output: message };
+  } else if (!json) {
+    process.stderr.write(
+      pin.applied.length ? `Remote feature flags pinned: ${pin.applied.join(", ")}
+` : "Remote feature flag overrides cleared.\n"
+    );
+  }
   if (!recordMobileSourceBaseline(target, source.fingerprint)) {
     const message = "Mobile source changed while the app was launching; the loaded-source baseline was not recorded.\n  Next: re-run mm-harness launch.";
     if (!json) process.stderr.write(`${message}
 `);
     return { status: EXIT.runtime, output: message };
   }
-  return result;
+  return { ...result, remoteFeatureFlags: provenFlags };
 }
 export {
   launchMobile

package/dist/commands/mobile-device-view.js

@@ -21,9 +21,16 @@ async function mobileDeviceLiveView(target, view) {
     liveMap,
     devicesWithLive,
     additionalReachableDevices: reachableDevices,
-    androidPortHints: selectedAndroidPortHints(view.devices, liveMap)
+    androidPortHints: selectedAndroidPortHints(view.devices, liveMap),
+    featureFlagOverrides: slotFeatureFlagOverrides(liveMap)
   };
 }
+function slotFeatureFlagOverrides(liveMap) {
+  for (const live of liveMap.values()) {
+    if (live.featureFlagOverrides) return live.featureFlagOverrides;
+  }
+  return null;
+}
 function scopedLiveMap(devices, allLiveMap) {
   const liveMap = /* @__PURE__ */ new Map();
   for (const device of devices) {

package/dist/commands/prepare.js

@@ -11,6 +11,7 @@ import { harnessExecutable, manifestPath, recipeRuntimeDir } from "../paths.js";
 import { optionFlag, optionString, parseArgs, targetPath, usageError } from "./parse-args.js";
 import { EXIT } from "./shared.js";
 import { formatDuration } from "./status-watch.js";
+import { FeatureFlagSpecError, parseRemoteFlagSpec } from "../feature-flags.js";
 const USAGE = "mm-harness prepare [--target <checkout>] [--platform mobile|extension|core] [--mobile-platform ios|android] [--clear-metro] [--artifacts-dir <dir>] [--json]";
 const REPORT_DIR = "prepare";
 const SKIPPED_AFTER_FAILURE = "previous step failed";
@@ -318,6 +319,21 @@ async function handlePrepare(argv) {
     throw usageError(`--clear-metro is mobile only; this checkout is ${platform}
   Next: ${USAGE}`);
   }
+  const remoteFlag = optionString(options, "remoteFlag");
+  if (remoteFlag !== void 0) {
+    if (platform === "core") {
+      throw usageError(`--remote-flag needs an app runtime; this checkout is core
+  Next: ${USAGE}`);
+    }
+    try {
+      parseRemoteFlagSpec(remoteFlag);
+    } catch (error) {
+      if (!(error instanceof FeatureFlagSpecError)) throw error;
+      throw usageError(`${error.message}
+  Next: ${error.userAction}`);
+    }
+  }
+  const remoteFlagArgs = remoteFlag === void 0 ? [] : ["--remote-flag", remoteFlag];
   let mobilePlatform = mobilePlatformOption(optionString(options, "mobilePlatform"));
   const recordPath = path.join(artifactsDir, READINESS_RECORD);
   const chain = stepChain(platform);
@@ -353,17 +369,18 @@ async function handlePrepare(argv) {
       addStep(skippedStep("fixtures", `${executable} fixtures set`, reason));
     } else if (platform === "mobile") {
       const device = mobilePlatform ? [mobilePlatform] : [];
-      await run("launch", ["launch", ...device, ...clearMetro ? ["--clear-metro"] : [], "--verify", "--json", ...targetArgs]);
+      await run("launch", ["launch", ...device, ...clearMetro ? ["--clear-metro"] : [], ...remoteFlagArgs, "--verify", "--json", ...targetArgs]);
       await run("fixtures", [
         "fixtures",
         "set",
         ...mobilePlatform ? ["--platform", mobilePlatform] : [],
+        ...remoteFlagArgs,
         "--json",
         ...targetArgs
       ]);
     } else {
-      await run("launch", ["launch", "--verify", "--json", ...targetArgs]);
-      await run("fixtures", ["fixtures", "set", "--json", ...targetArgs]);
+      await run("launch", ["launch", ...remoteFlagArgs, "--verify", "--json", ...targetArgs]);
+      await run("fixtures", ["fixtures", "set", ...remoteFlagArgs, "--json", ...targetArgs]);
     }
     await run("verify", ["verify", "--json", "--adapter", platform, ...targetArgs]);
   } finally {

package/dist/commands/run-engine.js

@@ -1344,7 +1344,16 @@ async function ensureExtensionProofRuntime(target, heal, state, json, deps = {})
     );
   const launch = deps.launch ?? (async (requestedTier) => {
     const { launchExtension } = await import("./launch/extension.js");
-    return launchExtension(target, requestedTier, false);
+    const { readExtensionPinnedFlags } = await import("../adapters/extension/feature-flags.js");
+    const { fixtureFeatureFlags, remoteFlagRequestFor } = await import("../feature-flags.js");
+    const { walletFixturePath } = await import("../paths.js");
+    return launchExtension(
+      target,
+      requestedTier,
+      false,
+      "fullscreen",
+      remoteFlagRequestFor(readExtensionPinnedFlags(target).pinned ?? fixtureFeatureFlags(walletFixturePath(target)))
+    );
   });
   const result = await launch(tier);
   const verified = result.status === 0 ? await decide() : initial;

package/dist/commands/runtime-launch.js

@@ -20,6 +20,7 @@ import {
   targetPath,
   usageError
 } from "./parse-args.js";
+import { FeatureFlagSpecError, parseRemoteFlagSpec } from "../feature-flags.js";
 async function handleRuntimeLaunch({ options }) {
   if (optionFlag(options, "help")) {
     console.log(`mm-harness runtime-launch --adapter <extension|mobile> --target <checkout> [flags]
@@ -129,7 +130,15 @@ async function handleRuntimeLaunch({ options }) {
   if (chromeUserDataDir) command.push("--chrome-user-data-dir", chromeUserDataDir);
   command.push(optionFlag(options, "resetProfile") ? "--reset-profile" : "--preserve-profile");
   const remoteFlag = optionString(options, "remoteFlag");
-  if (remoteFlag) command.push("--remote-flag", remoteFlag);
+  if (remoteFlag) {
+    try {
+      command.push("--remote-flags-json", JSON.stringify(parseRemoteFlagSpec(remoteFlag)));
+    } catch (error) {
+      if (!(error instanceof FeatureFlagSpecError)) throw error;
+      throw usageError(`${error.message}
+  Next: ${error.userAction}`);
+    }
+  }
   if (!fs.existsSync(liveScript)) {
     const report2 = runtimeLaunchReport("fail", {
       adapter,

package/dist/commands/status-probe.js

@@ -2,6 +2,7 @@ import { spawn } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { fixtureSummary } from "../doctor.js";
+import { normalizeFeatureFlagRecord } from "../feature-flags.js";
 import { runnerDir } from "../paths.js";
 const PROBE_TIMEOUT_MS = 2e3;
 function bridgeScriptPath() {
@@ -11,6 +12,15 @@ function truncateAddress(address) {
   if (!address || address.length <= 10) return address;
   return `${address.slice(0, 6)}\u2026${address.slice(-4)}`;
 }
+function entryFeatureFlagOverrides(entry) {
+  const flags = entry.featureFlags;
+  if (!flags || typeof flags !== "object") return void 0;
+  try {
+    return normalizeFeatureFlagRecord(flags.overrides ?? {}, "RemoteFeatureFlagController.localOverrides");
+  } catch {
+    return void 0;
+  }
+}
 function routeToString(route) {
   if (typeof route === "string") return route;
   if (route && typeof route === "object" && "name" in route) {
@@ -38,7 +48,8 @@ function parseBridgeEntries(raw) {
     platform: typeof e.platform === "string" ? e.platform : "",
     // agenticPresent is only set when the bridge explicitly sends it (false = absent).
     // An omitted value remains unknown.
-    ...typeof e.agenticPresent === "boolean" ? { agenticPresent: e.agenticPresent } : {}
+    ...typeof e.agenticPresent === "boolean" ? { agenticPresent: e.agenticPresent } : {},
+    ...e.featureFlags !== void 0 ? { featureFlags: e.featureFlags } : {}
   }));
 }
 function matchBridgeEntry(device, entries, devices) {
@@ -160,9 +171,11 @@ async function probeMobileLiveState(target, devices) {
     const currentScreen = routeToString(entry.route);
     const addrRaw = typeof account?.address === "string" ? account.address : void 0;
     const labelRaw = typeof account?.name === "string" ? account.name : void 0;
+    const overrides = entryFeatureFlagOverrides(entry);
     const liveEntry = {
       fixtureStatus,
       walletState,
+      ...overrides !== void 0 ? { featureFlagOverrides: overrides } : {},
       ...currentScreen !== void 0 ? { currentScreen } : {},
       ...labelRaw !== void 0 && addrRaw !== void 0 ? { selectedAccount: { label: labelRaw, address: truncateAddress(addrRaw) } } : {}
     };

package/dist/commands/status.js

@@ -1,5 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
+import { readExtensionPinnedFlags } from "../adapters/extension/feature-flags.js";
+import { featureFlagReport } from "../feature-flags.js";
 import { color } from "../cli-color.js";
 import { collectCheckoutView, renderCheckoutView } from "../checkout-view.js";
 import { detectAdapter } from "../harness.js";
@@ -49,6 +51,8 @@ async function handleStatus({ options }) {
     }
   }
   const next = surface.hints.relaunch;
+  const extensionFlags = adapter === "extension" ? readExtensionPinnedFlags(target) : null;
+  const staticFeatureFlags = extensionFlags ? featureFlagReport(extensionFlags.overrides, extensionFlags) : featureFlagReport(null);
   const deviceView = adapter === "mobile" ? mobileDeviceView(allDevices) : null;
   const devices = deviceView?.devices ?? [];
   const discovery = deviceView?.deviceDiscoveryErrors.length ? { deviceDiscoveryErrors: deviceView.deviceDiscoveryErrors } : {};
@@ -66,6 +70,7 @@ async function handleStatus({ options }) {
             target,
             view,
             devices: liveView.devicesWithLive,
+            featureFlags: featureFlagReport(liveView.featureFlagOverrides),
             ...discovery,
             ...liveView.additionalReachableDevices.length > 0 ? { additionalReachableDevices: liveView.additionalReachableDevices } : {},
             ...liveView.androidPortHints.length > 0 ? { androidPortHints: liveView.androidPortHints } : {},
@@ -86,6 +91,7 @@ async function handleStatus({ options }) {
             target,
             view,
             devices,
+            featureFlags: staticFeatureFlags,
             ...discovery,
             ...runtime ? { runtime } : {},
             next: discoveryNext ?? (runtime ? nextForRuntime(surface.hints.launch, surface.hints.relaunch, runtime) : next)
@@ -100,10 +106,12 @@ async function handleStatus({ options }) {
   const out = (style, text) => color(style, text, { stream: process.stdout });
   console.log(`${out("label", "status")} ${out("bold", adapter)} ${out("dim", target)}`);
   console.log(renderCheckoutView(view));
+  if (adapter !== "mobile") renderFeatureFlagLine(staticFeatureFlags, out);
   if (deviceView) renderMobileDeviceList(deviceView, out);
   if (!fast && adapter === "mobile" && deviceView !== null && deviceView.allConnectedDevices.length > 0) {
     const liveView = await mobileDeviceLiveView(target, deviceView);
     if (liveView.additionalReachableDevices.length > 0) renderAdditionalReachableDevices(liveView.additionalReachableDevices, out);
+    renderFeatureFlagLine(featureFlagReport(liveView.featureFlagOverrides), out);
     renderMobileLiveBlock(devices, liveView.liveMap, out);
     renderAndroidPortHints(liveView.androidPortHints, out);
     console.log(`${out("label", "Next:")} ${out("cmd", discoveryNext ?? nextForLive(next, liveView.liveMap))}`);
@@ -112,10 +120,15 @@ async function handleStatus({ options }) {
     renderRuntimeStatus(runtime, out);
     console.log(`${out("label", "Next:")} ${out("cmd", nextForRuntime(surface.hints.launch, surface.hints.relaunch, runtime))}`);
   } else {
+    if (adapter === "mobile") renderFeatureFlagLine(featureFlagReport(null), out);
     console.log(`${out("label", "Next:")} ${out("cmd", discoveryNext ?? next)}`);
   }
   return EXIT.ok;
 }
+function renderFeatureFlagLine(report, out) {
+  const style = report.error ? "warn" : (report.overrideCount ?? 0) > 0 ? "warn" : "dim";
+  console.log(`${out("label", "feature flags:")} ${out(style, report.summary.replace(/^feature flags: /u, ""))}`);
+}
 function renderRuntimeStatus(runtime, out) {
   const decisionStyle = runtime.decision === "ready" ? "ok" : runtime.decision === "blocked" ? "err" : "warn";
   const deps = runtime.deps ? ` deps=${out(runtime.deps === "current" ? "ok" : "warn", runtime.deps)}` : "";

package/dist/doctor.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { color } from "./cli-color.js";
+import { normalizeFeatureFlagRecord } from "./feature-flags.js";
 import {
   mobileToolRecovery,
   resolveMobileToolPath
@@ -85,11 +86,18 @@ function fixtureFileSummary(file, adapter, reportedPath = file) {
     const data = readJsonObject(file);
     const hasAccounts = Array.isArray(data.accounts) && data.accounts.length > 0;
     const hasPassword = typeof data.password === "string" && data.password.length > 0;
+    const remoteFeatureFlags = normalizeFeatureFlagRecord(
+      data["remoteFeatureFlags"],
+      String(reportedPath ?? file)
+    );
+    const flagKeys = Object.keys(remoteFeatureFlags);
     return {
       status: hasAccounts && (adapter === "core" || hasPassword) ? "ready" : "incomplete",
       path: reportedPath,
       accountCount: Array.isArray(data.accounts) ? data.accounts.length : 0,
-      hasPassword
+      hasPassword,
+      remoteFeatureFlagCount: flagKeys.length,
+      ...flagKeys.length > 0 ? { remoteFeatureFlags } : {}
     };
   } catch (error) {
     return { status: "invalid", path: reportedPath, error: error instanceof Error ? error.message : String(error) };