@deeeed/metamask-harness 0.59.0 → 0.61.0

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-watch.js

@@ -130,6 +130,9 @@ function renderTaskView(view, title, explicitTask = false) {
     }
     phase = row.phase;
     lines.push(renderRow(row, view.currentStep, out));
+    for (const unit of view.subtasks.filter((entry) => entry.parentStep === row.number)) {
+      lines.push(...renderSubtask(unit, out));
+    }
   }
   const signal = view.signal;
   if (signal) {
@@ -171,6 +174,21 @@ function changedLines(previous, next) {
     if (!row.checked || before.get(row.number) === true) continue;
     lines.push(`checked ${row.number} ${row.label}${row.durationMs !== void 0 ? ` (${formatDuration(row.durationMs)})` : ""}`);
   }
+  const beforeUnits = new Map(previous.subtasks.map((unit) => [unit.id, unit]));
+  for (const unit of next.subtasks) {
+    const before2 = beforeUnits.get(unit.id);
+    if (!before2) {
+      lines.push(`subtask ${unit.id} registered on step ${unit.parentStep} (${unit.rows.length} rows)`);
+    }
+    const beforeRows = new Map((before2?.rows ?? []).map((row) => [row.number, row.checked]));
+    for (const row of unit.rows) {
+      if (!row.checked || beforeRows.get(row.number) === true) continue;
+      lines.push(`subtask ${unit.id} checked ${row.number} ${row.label}`);
+    }
+    if (before2 && before2.status !== unit.status) {
+      lines.push(`subtask ${unit.id} ${unit.status ?? "unknown"}`);
+    }
+  }
   if (previous.signal?.step !== next.signal?.step && next.signal?.step) {
     lines.push(`step ${stepLabel(next.signal.step)}`);
   }
@@ -198,6 +216,20 @@ function renderRow(row, currentStep, out) {
   const text = row.checked ? out("dim", label) : out("bold", label);
   return ` ${marker} ${out("dim", number)} ${text}${timing ? ` ${out("dim", timing)}` : ""}`;
 }
+function renderSubtask(unit, out) {
+  const done = unit.rows.filter((row) => row.checked).length;
+  const header = joinParts([
+    `${out("label", "subtask")} ${out("accent", unit.id)}`,
+    statusWord(out, unit.status),
+    `${done}/${unit.rows.length}`,
+    unit.source?.ref && out("dim", unit.source.ref)
+  ]);
+  const current = unit.rows.find((row) => !row.checked);
+  return [
+    `     ${header}`,
+    ...unit.rows.map((row) => `    ${renderRow(row, current?.number, out)}`)
+  ];
+}
 function libraryLabel(library) {
   const home = os.homedir();
   const location = home && library.path.startsWith(`${home}/`) ? `~${library.path.slice(home.length)}` : library.path;

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) };

package/dist/feature-flags.js

@@ -0,0 +1,193 @@
+import { readFileSync } from "node:fs";
+const REMOTE_FLAG_USAGE = 'pass --remote-flag KEY=VALUE[,KEY=VALUE] \u2014 VALUE is a variant name (treatment), true/false, or JSON ({"enabled":true})';
+class FeatureFlagSpecError extends Error {
+  userAction;
+  constructor(message, userAction = REMOTE_FLAG_USAGE) {
+    super(message);
+    this.name = "FeatureFlagSpecError";
+    this.userAction = userAction;
+  }
+}
+const KEY_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$.-]*$/u;
+function assertKey(key, where) {
+  if (!key) {
+    throw new FeatureFlagSpecError(`${where} has an empty feature-flag key.`);
+  }
+  if (!KEY_PATTERN.test(key)) {
+    throw new FeatureFlagSpecError(
+      `${where} feature-flag key ${JSON.stringify(key)} is not a flag name; expected a remote feature-flag key such as perpsTAT3938AbtestScreenVsBottomSheet.`
+    );
+  }
+}
+function normalizeFeatureFlagValue(raw, where) {
+  if (typeof raw !== "string") {
+    if (raw === null) return null;
+    if (typeof raw === "boolean" || typeof raw === "number") return raw;
+    if (typeof raw === "object") return raw;
+    throw new FeatureFlagSpecError(
+      `${where} feature-flag value has unsupported type ${typeof raw}; use a variant name, true/false, or JSON.`
+    );
+  }
+  const value = raw.trim();
+  if (!value) {
+    throw new FeatureFlagSpecError(
+      `${where} has an empty feature-flag value; a flag needs a variant name, true/false, or JSON.`
+    );
+  }
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value.startsWith("{") || value.startsWith("[")) {
+    try {
+      return JSON.parse(value);
+    } catch (error) {
+      throw new FeatureFlagSpecError(
+        `${where} feature-flag value is not valid JSON: ${value} (${error instanceof Error ? error.message : String(error)}).`
+      );
+    }
+  }
+  return { name: value };
+}
+function splitPairs(spec) {
+  const pairs = [];
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  let current = "";
+  for (const char of spec) {
+    if (inString) {
+      current += char;
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === '"') inString = false;
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      current += char;
+      continue;
+    }
+    if (char === "{" || char === "[") depth += 1;
+    if (char === "}" || char === "]") depth -= 1;
+    if (char === "," && depth <= 0) {
+      pairs.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  pairs.push(current);
+  return pairs.map((pair) => pair.trim()).filter((pair) => pair.length > 0);
+}
+function parseRemoteFlagSpec(spec, where = "--remote-flag") {
+  const pairs = splitPairs(spec);
+  if (pairs.length === 0) {
+    throw new FeatureFlagSpecError(`${where} had no KEY=VALUE pairs: ${JSON.stringify(spec)}.`);
+  }
+  const flags = {};
+  for (const pair of pairs) {
+    const separator = pair.indexOf("=");
+    if (separator < 0) {
+      throw new FeatureFlagSpecError(`${where} expects KEY=VALUE, got: ${pair}.`);
+    }
+    const key = pair.slice(0, separator).trim();
+    assertKey(key, where);
+    if (Object.prototype.hasOwnProperty.call(flags, key)) {
+      throw new FeatureFlagSpecError(`${where} sets ${key} more than once; give each key one value.`);
+    }
+    flags[key] = normalizeFeatureFlagValue(pair.slice(separator + 1), where);
+  }
+  return flags;
+}
+function normalizeFeatureFlagRecord(raw, where) {
+  if (raw === void 0 || raw === null) return {};
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    throw new FeatureFlagSpecError(
+      `${where} remoteFeatureFlags must be an object of key \u2192 variant name, true/false, or JSON.`,
+      'edit the wallet fixture so remoteFeatureFlags is an object, e.g. { "perpsTAT3938AbtestScreenVsBottomSheet": "treatment" }'
+    );
+  }
+  const flags = {};
+  for (const [key, value] of Object.entries(raw)) {
+    assertKey(key, `${where} remoteFeatureFlags`);
+    flags[key] = normalizeFeatureFlagValue(value, `${where} remoteFeatureFlags.${key}`);
+  }
+  return flags;
+}
+function describeFeatureFlagValue(value) {
+  if (typeof value === "boolean" || typeof value === "number") return String(value);
+  if (typeof value === "string") return value;
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const named = value["name"];
+    if (typeof named === "string") return named;
+  }
+  return JSON.stringify(value);
+}
+function featureFlagReport(overrides, detail = {}) {
+  return {
+    summary: formatFeatureFlagLine(overrides, detail),
+    overrides,
+    overrideCount: overrides ? Object.keys(overrides).length : null,
+    ...detail.error ? { error: detail.error } : {},
+    ...detail.sourcePath ? { sourcePath: detail.sourcePath } : {}
+  };
+}
+function formatFeatureFlagLine(overrides, detail = {}) {
+  if (detail.error) {
+    return `feature flags: (unreadable${detail.sourcePath ? ` \u2014 ${detail.sourcePath}` : ""}: ${detail.error})`;
+  }
+  if (!overrides) return "feature flags: (no runtime)";
+  const entries = Object.entries(overrides);
+  if (entries.length === 0) return "feature flags: 0 override(s)";
+  const described = entries.map(([key, value]) => `${key}=${describeFeatureFlagValue(value)}`).join(", ");
+  return `feature flags: ${entries.length} override(s) ${described}`;
+}
+function sameFeatureFlags(a, b) {
+  const keys = [.../* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])];
+  return keys.every((key) => JSON.stringify(a[key]) === JSON.stringify(b[key]));
+}
+function fixtureFeatureFlags(fixturePath) {
+  let raw;
+  try {
+    raw = readFileSync(fixturePath, "utf8");
+  } catch {
+    return {};
+  }
+  let body;
+  try {
+    body = JSON.parse(raw);
+  } catch (error) {
+    throw new FeatureFlagSpecError(
+      `${fixturePath} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+      "fix the wallet fixture, or run mm-harness fixtures init to regenerate it"
+    );
+  }
+  return normalizeFeatureFlagRecord(body?.["remoteFeatureFlags"], fixturePath);
+}
+function remoteFlagRequestFor(flags) {
+  if (Object.keys(flags).length === 0) return void 0;
+  return { flags, json: JSON.stringify(flags), spec: toRemoteFlagSpec(flags) };
+}
+function toRemoteFlagSpec(flags) {
+  return Object.entries(flags).map(([key, value]) => {
+    if (typeof value === "boolean") return `${key}=${String(value)}`;
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      const named = value["name"];
+      if (typeof named === "string" && Object.keys(value).length === 1) return `${key}=${named}`;
+    }
+    return `${key}=${JSON.stringify(value)}`;
+  }).join(",");
+}
+export {
+  FeatureFlagSpecError,
+  REMOTE_FLAG_USAGE,
+  describeFeatureFlagValue,
+  featureFlagReport,
+  fixtureFeatureFlags,
+  formatFeatureFlagLine,
+  normalizeFeatureFlagRecord,
+  normalizeFeatureFlagValue,
+  parseRemoteFlagSpec,
+  remoteFlagRequestFor,
+  sameFeatureFlags,
+  toRemoteFlagSpec
+};

package/dist/mm-harness-cli.js

@@ -435,7 +435,13 @@ Example:
 Example (real actions; run mm-harness actions for this checkout's full set):
   mm-harness call ensure_unlocked --adapter extension   # a wallet action (extension/mobile)
   mm-harness call navigate page=perps --adapter mobile
-  mm-harness call command cmd="echo hi" --adapter core   # the universal action (all adapters)`
+  mm-harness call command cmd="echo hi" --adapter core   # the universal action (all adapters)
+
+Remote feature flags (mobile applies at runtime; extension pins at launch):
+  mm-harness call metamask.feature_flags.read --adapter mobile
+  mm-harness call metamask.feature_flags.set --adapter mobile \\
+    --arg 'flags={"perpsTAT3938AbtestScreenVsBottomSheet":"treatment"}'
+  mm-harness call metamask.feature_flags.clear --adapter mobile`
   },
   {
     name: "run",
@@ -691,6 +697,11 @@ Example:
   --surface <fullscreen|sidepanel>   Extension display mode (default: fullscreen)
   --sidepanel | --fullscreen         Legacy aliases for --surface
   --url <dapp-url>                    Open a dapp beside the sidepanel (default: MetaMask test dapp)
+  --remote-flag <KEY=VALUE[,...]>    Pin remote feature flags. VALUE is a variant name (treatment),
+                                     true/false, or JSON. Mobile applies it through
+                                     RemoteFeatureFlagController once the bridge is ready and fails the
+                                     launch if it does not read back; Extension pins it into the per-run
+                                     dist snapshot manifest (so it skips the reuse fast path).
   --heal <off|infra-only|auto>       Healing policy (default auto); bounds always enforced
   --device <udid|name>               Target simulator/device (env: IOS_SIMULATOR / ADB_SERIAL)
   --cdp-port <port>                  Extension CDP port (env: CDP_PORT / RECIPE_CDP_PORT)
@@ -704,7 +715,8 @@ Example:
   mm-harness launch ios
   mm-harness launch android --clear-metro --verify
   mm-harness launch ios --build
-  mm-harness launch --verify --json`
+  mm-harness launch --verify --json
+  mm-harness launch --remote-flag perpsTAT3938AbtestScreenVsBottomSheet=treatment`
   },
   {
     name: "logs",
@@ -849,6 +861,7 @@ Example:
   --extension-dir <path>             finalize: loaded extension dist (e.g. dist/chrome)
   --extension-id-file <path>         finalize: optional file to read/write the resolved extension id
   --action-manifest <path>           Extension set: override the wallet action manifest
+  --remote-flag <KEY=VALUE[,...]>    set/reset: one-run override layered over the fixture's remoteFeatureFlags
   --adapter <mobile|extension>       Target adapter (auto-detected inside a checkout)
   --target <path>                    Checkout path (default: cwd)
   --device <udid|serial|name>        Mobile only: target this device for sync/set

package/dist/task-view.js

@@ -7,8 +7,12 @@ import {
   deriveChecklistStepDurations,
   enumerateChecklistCheckboxes,
   INTERACTIVE_CHECKLIST_MARKDOWN,
+  isSettledSubtaskStatus,
   isTerminalWorkerSignalStatus,
   READINESS_RECORD,
+  SUBTASK_INDEX_FILE,
+  SUBTASKS_DIR,
+  subtaskPaths,
   WORKER_SIGNAL_FILE
 } from "@farmslot/protocol";
 import { readCommandJournal } from "./command-journal.js";
@@ -28,7 +32,9 @@ function collectTaskView(target, taskDir, now) {
       ({ name, root }) => ({ ...name ? { name } : {}, path: root })
     )
   };
-  if (!taskDir) return { ...base, checklist: [], activity: { ongoing: false, reason: "no-task" } };
+  if (!taskDir) {
+    return { ...base, checklist: [], subtasks: [], activity: { ongoing: false, reason: "no-task" } };
+  }
   const handoff = readJsonObject(path.join(taskDir, HANDOFF_INPUT));
   const fixtures = readJsonObject(path.join(taskDir, "artifacts", "prepare", "fixtures.json"));
   const sandbox = readJsonObject(path.join(taskDir, "artifacts", READINESS_RECORD)) ?? readJsonObject(path.join(target, recipeRuntimeDir(), READINESS_RECORD));
@@ -81,6 +87,7 @@ function collectTaskView(target, taskDir, now) {
     }),
     sandbox: section({ ready: pickBoolean(sandbox, "ready") }),
     checklist,
+    subtasks: readSubtasks(taskDir),
     signal: section({
       status: pickString(signal, "status"),
       step: pickString(signal, "step"),
@@ -167,6 +174,32 @@ function readChecklistRows(file) {
     checked: item.checked
   }));
 }
+function readSubtasks(taskDir) {
+  const index = readJsonObject(path.join(taskDir, SUBTASKS_DIR, SUBTASK_INDEX_FILE));
+  if (!index) return [];
+  const units = index.units;
+  if (!Array.isArray(units)) return [];
+  const views = [];
+  for (const entry of units) {
+    const unit = asObject(entry);
+    const id = pickString(unit, "id");
+    const parentStep = pickNumber(asObject(unit?.parent), "stepNumber");
+    if (id === void 0 || parentStep === void 0) continue;
+    const paths = subtaskPaths(id);
+    const signal = readJsonObject(path.join(taskDir, paths.signal));
+    const status = pickString(signal, "status");
+    const source = asObject(unit?.source);
+    views.push({
+      id,
+      parentStep,
+      ...status !== void 0 ? { status } : {},
+      settled: isSettledSubtaskStatus(status),
+      rows: readChecklistRows(path.join(taskDir, paths.checklist)),
+      ...section({ kind: pickString(source, "kind"), ref: pickString(source, "ref") }) ? { source: section({ kind: pickString(source, "kind"), ref: pickString(source, "ref") }) } : {}
+    });
+  }
+  return views;
+}
 function trimLabel(text) {
   const plain = checklistStepName(text).replace(/\*\*/gu, "").replace(/^\d+\.\s*/u, "").replace(/\s+/gu, " ").trim();
   if (plain.length <= CHECKLIST_LABEL_LIMIT) return plain;

package/library/actions/core/feature_flags/_unsupported.mjs

@@ -0,0 +1,29 @@
+// Core is the headless adapter: it drives controllers over HTTP and runs no app
+// runtime, so there is no RemoteFeatureFlagController and no manifest to pin.
+// Reads answer `{ supported: false }` with exit 0 (an honest empty observation);
+// mutations exit non-zero so nobody records a variant that was never applied.
+import { readFile, writeFile } from 'node:fs/promises';
+
+export const CORE_UNSUPPORTED_REASON =
+  'core is headless: it has no app runtime, so it holds no RemoteFeatureFlagController and no extension manifest to pin. Run this action against the mobile or extension adapter.';
+
+export async function runCoreFeatureFlagStub({ mutation }) {
+  const inputPath = process.argv[2] || process.env.METAMASK_RECIPE_ADAPTER_INPUT;
+  if (!inputPath) throw new Error('Adapter input path is required.');
+  const input = JSON.parse(await readFile(inputPath, 'utf8'));
+  const output = {
+    action: input.action,
+    source: 'core-headless',
+    supported: false,
+    reason: CORE_UNSUPPORTED_REASON,
+    effective: {},
+    overrides: {},
+    next: `mm-harness call ${input.action} --adapter mobile --target <metamask-mobile-checkout>`,
+    proofPath: 'core-feature-flags-unsupported',
+  };
+  if (input.outputPath) await writeFile(input.outputPath, `${JSON.stringify(output, null, 2)}\n`);
+  else process.stdout.write(`${JSON.stringify(output)}\n`);
+  if (mutation) {
+    throw new Error(`${input.action} is not supported on core. ${CORE_UNSUPPORTED_REASON}\n  Next: ${output.next}`);
+  }
+}

package/library/actions/core/feature_flags/clear.mjs

@@ -0,0 +1,8 @@
+// core has no runtime feature flags — answer honestly instead of fabricating one.
+import { pathToFileURL } from 'node:url';
+
+import { runCoreFeatureFlagStub } from './_unsupported.mjs';
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  await runCoreFeatureFlagStub({ mutation: true });
+}

package/library/actions/core/feature_flags/read.mjs

@@ -0,0 +1,8 @@
+// core has no runtime feature flags — answer honestly instead of fabricating one.
+import { pathToFileURL } from 'node:url';
+
+import { runCoreFeatureFlagStub } from './_unsupported.mjs';
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  await runCoreFeatureFlagStub({ mutation: false });
+}

package/library/actions/core/feature_flags/set.mjs

@@ -0,0 +1,8 @@
+// core has no runtime feature flags — answer honestly instead of fabricating one.
+import { pathToFileURL } from 'node:url';
+
+import { runCoreFeatureFlagStub } from './_unsupported.mjs';
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  await runCoreFeatureFlagStub({ mutation: true });
+}

package/library/actions/extension/feature_flags/clear.mjs

@@ -0,0 +1,48 @@
+// Clear overrides when there are none; otherwise name the relaunch that drops the pin.
+//
+// The extension's overrides live in the per-run dist snapshot manifest, which is
+// re-created at launch. A slot with no pin is already clear (exit 0); a pinned
+// slot needs a relaunch without --remote-flag, so this refuses rather than
+// reporting a clear it did not perform.
+import { runAdapter, withExtensionPage, writeOutput } from '../platform/cdp.mjs';
+import { EXTENSION_SET_UNSUPPORTED_REASON, readFeatureFlagsExpression, resolveOverrides } from './state.mjs';
+
+runAdapter(async (input) => {
+  const state = await withExtensionPage(input, (page) =>
+    page.evaluate(readFeatureFlagsExpression(), { awaitPromise: true }));
+  const resolved = resolveOverrides(state, input.context?.projectRoot);
+  const effective = { ...state.stateFlags, ...resolved.overrides };
+  const pinned = Object.keys(resolved.overrides);
+  const target = String(input.context?.projectRoot ?? '<extension-checkout>');
+  const quoted = /[^A-Za-z0-9_@%+=:,./-]/u.test(target) ? `'${target.replaceAll("'", "'\\''")}'` : target;
+  const next = `mm-harness launch --adapter extension --target ${quoted}`;
+  if (pinned.length === 0) {
+    return {
+      action: input.action,
+      source: 'extension-manifest-pin',
+      supported: true,
+      cleared: [],
+      overrides: {},
+      effective,
+      overrideSource: resolved.overrideSource,
+      needsRelaunch: false,
+      proofPath: 'extension-remote-feature-flags',
+    };
+  }
+  await writeOutput(input, {
+    action: input.action,
+    source: 'extension-manifest-pin',
+    supported: false,
+    reason: EXTENSION_SET_UNSUPPORTED_REASON,
+    cleared: [],
+    overrides: resolved.overrides,
+    effective,
+    overrideSource: resolved.overrideSource,
+    needsRelaunch: true,
+    next,
+    proofPath: 'extension-remote-feature-flags',
+  });
+  throw new Error(
+    `metamask.feature_flags.clear cannot drop the extension manifest pin at runtime (${pinned.join(', ')}). ${EXTENSION_SET_UNSUPPORTED_REASON}\n  Next: ${next}`,
+  );
+});

package/library/actions/extension/feature_flags/read.mjs

@@ -0,0 +1,27 @@
+// Read the effective remote feature flags and the manifest pin from the running extension.
+import { runAdapter, withExtensionPage } from '../platform/cdp.mjs';
+import { readFeatureFlagsExpression, resolveOverrides, selectKeys } from './state.mjs';
+
+runAdapter((input) => withExtensionPage(input, async (page) => {
+  const keys = Array.isArray(input.node?.keys) ? input.node.keys.map(String) : [];
+  const state = await page.evaluate(readFeatureFlagsExpression(), { awaitPromise: true });
+  const resolved = resolveOverrides(state, input.context?.projectRoot);
+  // The extension merges the manifest pin over the fetched flags, manifest wins.
+  const effective = { ...state.stateFlags, ...resolved.overrides };
+  return {
+    action: input.action,
+    source: 'extension-manifest-pin-and-controller-state',
+    overrideSource: resolved.overrideSource,
+    ...(resolved.overrideSourcePath ? { overrideSourcePath: resolved.overrideSourcePath } : {}),
+    ...(resolved.manifestUnreadableReason
+      ? { manifestUnreadableReason: resolved.manifestUnreadableReason }
+      : {}),
+    effective: selectKeys(effective, keys),
+    overrides: selectKeys(resolved.overrides, keys),
+    overrideCount: Object.keys(resolved.overrides).length,
+    fetched: selectKeys(state.stateFlags, keys),
+    thresholdGroups: state.thresholdGroups,
+    supported: true,
+    proofPath: 'extension-remote-feature-flags',
+  };
+}));