@sun-asterisk/sungen 3.2.3 → 3.2.4

package/src/cli/commands/feedback.ts

@@ -1,62 +1,134 @@
+/**
+ * `sungen feedback "<content>"` — submit PRODUCT feedback to the remote backend.
+ *
+ * One markdown record per call. Content comes from the positional arg, piped
+ * stdin, or — when run bare in a TTY — an $EDITOR session. Login-gated:
+ * missing/expired token prompts an interactive login. The author (created_by)
+ * is NEVER sent; the backend stamps it from the bearer token.
+ *
+ * NOTE: distinct from `sungen qa-feedback` (commands/qa-feedback.ts) — that writes
+ * the LOCAL QA-feedback log and is what the /sungen:feedback slash command calls.
+ */
+
 import { Command } from 'commander';
-import { recordFeedback, summarize, FeedbackType, FeedbackDecision } from '../../harness/feedback';
+import * as readline from 'readline';
+import { loadCredentials, isExpired } from '../../tools/sungen-auth/credentials-store';
+import { resolveApiBaseUrl } from '../../tools/sungen-auth/api-base-url';
+import { performLogin } from './login';
+import { submitFeedback, AuthExpiredError, FeedbackPayload } from '../../tools/sungen-api/feedback-client';
+import { readStdin } from '../../tools/sungen-api/read-stdin';
+import { composeInEditor } from '../../tools/sungen-api/edit-in-editor';
 
-const TYPES = ['test-design', 'product', 'other'];
-const DECISIONS = ['accept', 'reject', 'edit', 'add', 'none'];
+const CATEGORIES = ['quality', 'feature_request', 'bug', 'other'];
+const QA_WORDS = ['record', 'list'];
+const MAX_CONTENT_LEN = 10_000;
 
-export function registerFeedbackCommand(program: Command): void {
-  const fb = program
-    .command('feedback')
-    .description('Local-first QA feedback (test-design knowledge + product telemetry). Synced later when a server exists.');
+// CLI version → sungen_version; same source as cli/index.ts so it never drifts.
+const { version: SUNGEN_VERSION } = require('../../../package.json') as { version: string };
 
-  fb
-    .command('record')
-    .description('Record a feedback entry')
-    .requiredOption('--message <text>', 'The feedback')
-    .option('--type <t>', `Feedback type (${TYPES.join('|')})`, 'test-design')
-    .option('-s, --screen <name>', 'Screen/flow the feedback relates to')
-    .option('--target <ref>', 'What it is about (viewpoint id / scenario / command / artifact)')
-    .option('--decision <d>', `QA decision (${DECISIONS.join('|')})`, 'none')
-    .option('--reason <text>', 'Why')
-    .option('--source <who>', 'Who gave the feedback', 'qa')
-    .action((o) => {
-      try {
-        if (!TYPES.includes(o.type)) throw new Error(`--type must be one of ${TYPES.join(', ')}`);
-        if (!DECISIONS.includes(o.decision)) throw new Error(`--decision must be one of ${DECISIONS.join(', ')}`);
-        const p = recordFeedback({
-          type: o.type as FeedbackType,
-          screen: o.screen,
-          target: o.target,
-          decision: o.decision as FeedbackDecision,
-          message: o.message,
-          reason: o.reason,
-          source: o.source,
-        });
-        console.log(`✓ feedback recorded (${o.type}${o.screen ? ' · ' + o.screen : ''}) → ${p}`);
-      } catch (e) {
-        console.error('Error:', e instanceof Error ? e.message : e);
-        process.exit(1);
-      }
+/** Ask a yes/no question on the terminal; defaults to "no" on empty input. */
+function promptYesNo(question: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(/^y(es)?$/i.test(answer.trim()));
     });
+  });
+}
+
+/** Resolve feedback content from positional arg or piped stdin. */
+async function resolveContent(positional?: string): Promise<string | null> {
+  if (positional && positional.trim()) return positional;
+  const piped = await readStdin();
+  if (piped && piped.trim()) return piped;
+  return null;
+}
+
+/** Ensure we have a valid token; prompt an interactive login if not. Returns creds or null if the user declines. */
+async function ensureLogin(apiBaseUrl: string): Promise<{ token: string; api_base_url: string } | null> {
+  const creds = loadCredentials();
+  if (creds && !isExpired(creds)) return creds;
+
+  const reason = creds ? 'Your session has expired.' : 'You are not logged in.';
+  const yes = await promptYesNo(`${reason} Log in now? (y/n) `);
+  if (!yes) return null;
+  return performLogin(apiBaseUrl);
+}
 
-  fb
-    .command('list')
-    .description('List / summarise recorded feedback')
-    .option('-s, --screen <name>', 'Filter by screen')
-    .option('--type <t>', 'Filter by type')
-    .option('--json', 'Output raw JSON')
-    .action((o) => {
+export function registerFeedbackCommand(program: Command): void {
+  program
+    .command('feedback [content]')
+    .description('Send product feedback about sungen (one record; pass as an argument, pipe via stdin, or run with no argument to compose in $EDITOR)')
+    .option('--category <c>', `Feedback category (${CATEGORIES.join('|')})`, 'other')
+    .option('--api-base-url <url>', 'Backend base URL (overrides SUNGEN_API_BASE_URL + stored value)')
+    .action(async (content: string | undefined, options: { category: string; apiBaseUrl?: string }) => {
       try {
-        const s = summarize({ screen: o.screen, type: o.type });
-        if (o.json) { console.log(JSON.stringify(s, null, 2)); return; }
-        console.log(`\n━━━ Feedback (${s.total}) ━━━`);
-        console.log(`  by type: ${Object.entries(s.byType).map(([k, v]) => `${k}=${v}`).join('  ') || '—'}`);
-        console.log(`  by decision: ${Object.entries(s.byDecision).map(([k, v]) => `${k}=${v}`).join('  ') || '—'}\n`);
-        for (const e of s.entries.slice(-20)) {
-          console.log(`  [${e.type}${e.decision && e.decision !== 'none' ? '/' + e.decision : ''}] ${e.screen ? e.screen + ' · ' : ''}${e.target ? e.target + ' — ' : ''}${e.message}`);
-          if (e.reason) console.log(`      reason: ${e.reason}`);
+        // Footgun guard: a bare `record`/`list` with no stdin is almost certainly
+        // someone reaching for the moved QA primitive, not real feedback text.
+        if (content && QA_WORDS.includes(content.trim()) && process.stdin.isTTY) {
+          console.error(
+            `The local QA log moved to \`sungen qa-feedback ${content.trim()}\`.\n` +
+            `To send "${content.trim()}" as product feedback, pipe it via stdin: echo "${content.trim()}" | sungen feedback`,
+          );
+          process.exit(1);
+        }
+
+        let text = await resolveContent(content);
+        if (!text) {
+          if (process.stdin.isTTY) {
+            // No arg and interactive: open the editor (like `git commit`).
+            text = composeInEditor();
+            if (!text) {
+              console.error('Aborting — no feedback provided (empty message).');
+              process.exit(1);
+            }
+          } else {
+            // Piped but empty.
+            console.error('Provide feedback text as an argument or pipe it via stdin.');
+            process.exit(1);
+          }
+        }
+        if (text.length > MAX_CONTENT_LEN) {
+          console.error(`Feedback is too long (${text.length} chars; max ${MAX_CONTENT_LEN}).`);
+          process.exit(1);
+        }
+
+        if (!CATEGORIES.includes(options.category)) {
+          console.error(`--category must be one of ${CATEGORIES.join(', ')}`);
+          process.exit(1);
+        }
+
+        const apiBaseUrl = resolveApiBaseUrl(options.apiBaseUrl);
+        const creds = await ensureLogin(apiBaseUrl);
+        if (!creds) {
+          console.error('Run `sungen login` first, then re-send your feedback.');
+          process.exit(1);
+        }
+
+        const payload: FeedbackPayload = {
+          content: text,
+          category: options.category,
+          sungen_version: SUNGEN_VERSION,
+          os: process.platform,
+          source: 'cli',
+        };
+
+        try {
+          const { id } = await submitFeedback(creds.api_base_url, creds.token, payload);
+          console.log(`Feedback submitted (id=${id}).`);
+        } catch (err) {
+          if (err instanceof AuthExpiredError) {
+            // Token died between load and POST — re-login once, then retry.
+            const yes = await promptYesNo('Your session expired. Log in again and retry? (y/n) ');
+            if (!yes) { console.error('Aborted.'); process.exit(1); }
+            const fresh = await performLogin(apiBaseUrl);
+            const { id } = await submitFeedback(fresh.api_base_url, fresh.token, payload);
+            console.log(`Feedback submitted (id=${id}).`);
+          } else {
+            throw err;
+          }
         }
-        console.log('');
       } catch (e) {
         console.error('Error:', e instanceof Error ? e.message : e);
         process.exit(1);

package/src/cli/commands/login.ts

@@ -0,0 +1,75 @@
+/**
+ * `sungen login` / `sungen logout`.
+ *
+ * login  — RFC 8252 native-app login (PKCE-S256 + loopback + one-time code)
+ *          against the FastSchema backend; caches the token at
+ *          ~/.sungen/credentials.json (0600).
+ * logout — clears that file.
+ *
+ * Mirrors the structure of `commands/figma.ts` (commander + scrubbed errors).
+ */
+
+import { Command } from 'commander';
+import { generatePkce, randomCorrelation } from '../../tools/sungen-auth/pkce';
+import { startLoopback } from '../../tools/sungen-auth/loopback-server';
+import { runLoginFlow } from '../../tools/sungen-auth/login-flow';
+import { saveCredentials, clearCredentials, credentialsPath } from '../../tools/sungen-auth/credentials-store';
+import { openBrowser } from '../../tools/sungen-auth/open-browser';
+import { resolveApiBaseUrl } from '../../tools/sungen-auth/api-base-url';
+import type { Credentials } from '../../tools/sungen-auth/sungen-auth-types';
+
+/**
+ * Run the full login flow against `apiBaseUrl`, persist the token, and return
+ * the stored credentials. Reused by `sungen feedback` for on-demand re-auth.
+ */
+export async function performLogin(apiBaseUrl: string): Promise<Credentials> {
+  const pkce = generatePkce();
+  const correlation = randomCorrelation();
+  const loopback = await startLoopback();
+  try {
+    const result = await runLoginFlow({
+      apiBaseUrl,
+      pkce,
+      correlation,
+      redirectUri: loopback.redirectUri,
+      openBrowser,
+      waitForCode: (corr, timeoutMs) => loopback.waitForCode(corr, timeoutMs),
+    });
+    const creds: Credentials = {
+      token: result.token,
+      email: result.email,
+      api_base_url: apiBaseUrl,
+      expires_at: result.expires_at,
+    };
+    saveCredentials(creds);
+    return creds;
+  } finally {
+    loopback.close();
+  }
+}
+
+export function registerLoginCommand(program: Command): void {
+  program
+    .command('login')
+    .description('Log in to the sungen feedback backend (opens your browser)')
+    .option('--api-base-url <url>', 'Backend base URL (overrides SUNGEN_API_BASE_URL + stored value)')
+    .action(async (options: { apiBaseUrl?: string }) => {
+      const apiBaseUrl = resolveApiBaseUrl(options.apiBaseUrl);
+      try {
+        const creds = await performLogin(apiBaseUrl);
+        console.log(`Logged in as ${creds.email}.`);
+        console.log(`Token saved to ${credentialsPath()} (mode 0600).`);
+      } catch (err: any) {
+        console.error(`Login failed: ${err?.message ?? err}`);
+        process.exit(1);
+      }
+    });
+
+  program
+    .command('logout')
+    .description('Remove the cached sungen login token')
+    .action(() => {
+      clearCredentials();
+      console.log(`Logged out. Removed ${credentialsPath()} (if present).`);
+    });
+}

package/src/cli/commands/qa-feedback.ts

@@ -0,0 +1,77 @@
+/**
+ * `sungen qa-feedback` — the LOCAL QA-feedback log (test-design knowledge +
+ * product telemetry), persisted to .sungen/feedback/feedback.jsonl.
+ *
+ * This is the persistence primitive behind the `/sungen:feedback` slash command
+ * (which auto-attaches screen/viewpoint/decision context and then calls
+ * `sungen qa-feedback record`). It is rarely typed by hand.
+ *
+ * NOTE: distinct from `sungen feedback` (see commands/feedback.ts) — that command
+ * submits PRODUCT feedback to the remote backend. This one only writes locally.
+ */
+
+import { Command } from 'commander';
+import { recordFeedback, summarize, FeedbackType, FeedbackDecision } from '../../harness/feedback';
+
+const TYPES = ['test-design', 'product', 'other'];
+const DECISIONS = ['accept', 'reject', 'edit', 'add', 'none'];
+
+export function registerQaFeedbackCommand(program: Command): void {
+  const fb = program
+    .command('qa-feedback')
+    .description('Local-first QA feedback log (test-design knowledge + product telemetry). Primarily invoked by the /sungen:feedback slash command.');
+
+  fb
+    .command('record')
+    .description('Record a feedback entry')
+    .requiredOption('--message <text>', 'The feedback')
+    .option('--type <t>', `Feedback type (${TYPES.join('|')})`, 'test-design')
+    .option('-s, --screen <name>', 'Screen/flow the feedback relates to')
+    .option('--target <ref>', 'What it is about (viewpoint id / scenario / command / artifact)')
+    .option('--decision <d>', `QA decision (${DECISIONS.join('|')})`, 'none')
+    .option('--reason <text>', 'Why')
+    .option('--source <who>', 'Who gave the feedback', 'qa')
+    .action((o) => {
+      try {
+        if (!TYPES.includes(o.type)) throw new Error(`--type must be one of ${TYPES.join(', ')}`);
+        if (!DECISIONS.includes(o.decision)) throw new Error(`--decision must be one of ${DECISIONS.join(', ')}`);
+        const p = recordFeedback({
+          type: o.type as FeedbackType,
+          screen: o.screen,
+          target: o.target,
+          decision: o.decision as FeedbackDecision,
+          message: o.message,
+          reason: o.reason,
+          source: o.source,
+        });
+        console.log(`✓ feedback recorded (${o.type}${o.screen ? ' · ' + o.screen : ''}) → ${p}`);
+      } catch (e) {
+        console.error('Error:', e instanceof Error ? e.message : e);
+        process.exit(1);
+      }
+    });
+
+  fb
+    .command('list')
+    .description('List / summarise recorded feedback')
+    .option('-s, --screen <name>', 'Filter by screen')
+    .option('--type <t>', 'Filter by type')
+    .option('--json', 'Output raw JSON')
+    .action((o) => {
+      try {
+        const s = summarize({ screen: o.screen, type: o.type });
+        if (o.json) { console.log(JSON.stringify(s, null, 2)); return; }
+        console.log(`\n━━━ Feedback (${s.total}) ━━━`);
+        console.log(`  by type: ${Object.entries(s.byType).map(([k, v]) => `${k}=${v}`).join('  ') || '—'}`);
+        console.log(`  by decision: ${Object.entries(s.byDecision).map(([k, v]) => `${k}=${v}`).join('  ') || '—'}\n`);
+        for (const e of s.entries.slice(-20)) {
+          console.log(`  [${e.type}${e.decision && e.decision !== 'none' ? '/' + e.decision : ''}] ${e.screen ? e.screen + ' · ' : ''}${e.target ? e.target + ' — ' : ''}${e.message}`);
+          if (e.reason) console.log(`      reason: ${e.reason}`);
+        }
+        console.log('');
+      } catch (e) {
+        console.error('Error:', e instanceof Error ? e.message : e);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/index.ts

@@ -23,6 +23,7 @@ import { registerEvalCommand } from './commands/eval';
 import { registerManifestCommand } from './commands/manifest';
 import { registerLedgerCommand } from './commands/ledger';
 import { registerFeedbackCommand } from './commands/feedback';
+import { registerQaFeedbackCommand } from './commands/qa-feedback';
 import { registerScriptCheckCommand } from './commands/script-check';
 import { registerTraceCommand } from './commands/trace';
 import { registerChallengeCommand } from './commands/challenge';
@@ -31,6 +32,7 @@ import { registerCapabilityCommand } from './commands/capability';
 import { registerFlowCheckCommand } from './commands/flow-check';
 import { registerContextCommand } from './commands/context';
 import { registerRepairCommand } from './commands/repair';
+import { registerLoginCommand } from './commands/login';
 import { capabilityRegistry } from '../capabilities/registry';
 import { discoverAndRegisterCapabilities } from '../capabilities/discover';
 
@@ -66,6 +68,7 @@ async function main() {
   registerManifestCommand(program);
   registerLedgerCommand(program);
   registerFeedbackCommand(program);
+  registerQaFeedbackCommand(program);
   registerScriptCheckCommand(program);
   registerTraceCommand(program);
   registerChallengeCommand(program);
@@ -76,6 +79,7 @@ async function main() {
   registerRepairCommand(program);
   registerIngestCommand(program);
   registerEvalCommand(program);
+  registerLoginCommand(program);
 
   // Capability-contributed CLI commands (Capability SPI): drivers own their authoring commands
   // (e.g. @sungen/driver-api → `sungen api import`). Discover, then register each.

package/src/dashboard/snapshot-builder.ts

@@ -85,6 +85,23 @@ export function buildDashboardSnapshot(options: BuildSnapshotOptions): Dashboard
 // Per-target build
 // ----------------------------------------------------------------------------
 
+/**
+ * True when this is a mobile project (`platform: mobile` in qa/capabilities.yaml).
+ * Mobile projects run per-OS (android/ios) — the dashboard surfaces those on a
+ * distinct platform axis (one FeatureSnapshot per OS) rather than as locale tabs.
+ * Mirrors `isMobileProject` in src/cli/commands/delivery.ts.
+ */
+function isMobileProject(cwd: string): boolean {
+  try {
+    const p = path.join(cwd, 'qa', 'capabilities.yaml');
+    if (!fs.existsSync(p)) return false;
+    const parsed = parseYaml(fs.readFileSync(p, 'utf-8')) as { platform?: string } | null;
+    return parsed?.platform === 'mobile';
+  } catch {
+    return false;
+  }
+}
+
 function buildOneScreen(
   cwd: string,
   target: DashboardTarget,
@@ -105,28 +122,46 @@ function buildOneScreen(
   const specMdFile = path.join(base, 'requirements', 'spec.md');
   const specLink = fs.existsSync(specMdFile) ? path.relative(cwd, specMdFile) : undefined;
 
+  const mobile = isMobileProject(cwd);
   const features: FeatureSnapshot[] = [];
   for (const featureBaseName of featureBaseNames) {
-    const fs2 = buildOneFeature(cwd, target, featureBaseName, env, specLink);
-    if (fs2) features.push(fs2);
+    features.push(...buildOneFeature(cwd, target, featureBaseName, env, specLink, mobile));
   }
   if (features.length === 0) return null;
 
   // Flat scenarios across all features (each scenario already carries its
   // own `featureBaseName`, so consumers that want to group can do so cheaply).
+  // For mobile, per-OS features flatten here so the Compare view can key each
+  // scenario by (tcId, platform) via its OS-precise testEnvironment.
   const scenarios = features.flatMap((f) => f.scenarios);
   const label = target.isFlow ? `flow/${target.name}` : target.name;
-  const primary = features[0];
+
+  // Screen-level platform axis: 'mobile' when any feature is OS-tagged; the
+  // union of OSes that actually produced a result file this run.
+  const execSet = new Set<'android' | 'ios'>();
+  let anyPlatform = false;
+  for (const f of features) {
+    if (f.platform) anyPlatform = true;
+    for (const p of f.executedPlatforms ?? []) execSet.add(p);
+  }
+  const executedPlatforms = execSet.size > 0
+    ? (['android', 'ios'] as const).filter((p) => execSet.has(p))
+    : undefined;
+  // Representative feature for the back-compat top-level fields: prefer Android
+  // (deterministic, matches delivery's summary-row preference).
+  const primary = features.find((f) => f.platform === 'android') ?? features[0];
 
   return {
     name: label,
     isFlow: target.isFlow,
+    platform: anyPlatform ? 'mobile' : undefined,
     featureName: primary.featureName,
     featurePath: primary.featurePath,
     specLink,
     summary: rollupScreenSummary(features),
     scenarios,
     features,
+    executedPlatforms,
   };
 }
 
@@ -141,14 +176,15 @@ function buildOneFeature(
   featureBaseName: string,
   env: EnvironmentInfo,
   specLink: string | undefined,
-): FeatureSnapshot | null {
+  mobile: boolean,
+): FeatureSnapshot[] {
   const base = qaDir(cwd, target);
   const genBase = generatedDir(cwd, target);
   const featureFile = path.join(base, 'features', `${featureBaseName}.feature`);
   const testDataFile = path.join(base, 'test-data', `${featureBaseName}.yaml`);
   const specFile = path.join(genBase, `${featureBaseName}.spec.ts`);
 
-  if (!fs.existsSync(featureFile)) return null;
+  if (!fs.existsSync(featureFile)) return [];
 
   const feature = parseFeatureMetadata(featureFile);
   const spec = fs.existsSync(specFile)
@@ -168,27 +204,16 @@ function buildOneFeature(
   // Discover locale variants by scanning <feature>-test-result*.json files.
   // Always includes base ('') as the first entry, even if its results file
   // is missing — UI still needs to render the feature.
-  // NOTE (mobile): for a `platform: mobile` project the "locale" variants are
-  // actually the per-OS runs (android / ios) — the dashboard reuses the locale
-  // switcher to surface them as tabs. The env column per tab is OS-precise (see
-  // resolvePlatformAppId below), but the top-level featurePath (base variant)
-  // defaults to the Android id. Delivery has a dedicated per-OS path; aligning the
-  // dashboard onto a distinct "platform" axis is a possible follow-up.
   const variants = discoverLocaleVariants(genBase, featureBaseName);
 
-  // Build per-locale ScreenSnapshot, then collect into FeatureSnapshot.locales[].
-  // Base variant is also used to populate the top-level (`scenarios`, `summary`)
-  // for back-compat with consumers that don't read the locales array.
-  const locales: LocaleSnapshot[] = [];
-  let baseBuilt: { scenarios: ScenarioSnapshot[]; summary: ScreenSummaryStats; featureName: string; featurePath?: string; specLink?: string } | null = null;
-
-  for (const variant of variants) {
+  // Build one per-variant ScreenSnapshot (test-data overlay + results + OS-precise
+  // env column). Reused by both the web/i18n (locale-axis) and mobile (platform-axis) paths.
+  const buildVariant = (variant: FeatureLocaleVariant) => {
     const testData = fs.existsSync(testDataFile)
       ? loadTestData(testDataFile, variant.locale || null)
       : {};
     const results = variant.resultsPath ? loadPlaywrightReport(variant.resultsPath) : null;
-
-    const built = buildScreenSnapshot({
+    return buildScreenSnapshot({
       screen: featureBaseName,
       isFlow: target.isFlow,
       featureName: feature.featureName,
@@ -203,17 +228,65 @@ function buildOneFeature(
       featureBaseName,
       selectorKeyMap,
     });
+  };
+  type Built = ReturnType<typeof buildVariant>;
+
+  // -- Mobile (platform axis): the per-OS runs (android / ios) are their own
+  //    FeatureSnapshot entries — one per OS, `platform` tagged — NOT locale tabs.
+  //    Locale overlays for a given OS (e.g. `android.ja`) nest inside that OS's
+  //    entry as `locales[]`. This mirrors the delivery per-OS deliverables. --
+  if (mobile) {
+    const osOf = (loc: string): 'android' | 'ios' | null =>
+      /^android(\.|$)/.test(loc) ? 'android' : /^ios(\.|$)/.test(loc) ? 'ios' : null;
+    const osVariants = variants.filter((v) => osOf(v.locale));
+    if (osVariants.length > 0) {
+      const executedPlatforms = (['android', 'ios'] as const).filter((os) =>
+        osVariants.some((v) => osOf(v.locale) === os && v.resultsPath)
+      );
+      const feats: FeatureSnapshot[] = [];
+      for (const os of ['android', 'ios'] as const) {
+        const group = osVariants.filter((v) => osOf(v.locale) === os);
+        if (group.length === 0) continue;
+        const localeSnaps: LocaleSnapshot[] = [];
+        let primaryBuilt: Built | null = null;
+        for (const v of group) {
+          const built = buildVariant(v);
+          localeSnaps.push({ locale: v.locale, displayCode: v.displayCode, summary: built.summary, scenarios: built.scenarios });
+          // Representative = the bare OS run (locale === os); else the first overlay.
+          if (v.locale === os || !primaryBuilt) primaryBuilt = built;
+        }
+        if (!primaryBuilt) continue;
+        feats.push({
+          featureBaseName,
+          featureName: primaryBuilt.featureName,
+          featurePath: primaryBuilt.featurePath,
+          specLink: primaryBuilt.specLink,
+          summary: primaryBuilt.summary,
+          scenarios: primaryBuilt.scenarios,
+          platform: os,
+          executedPlatforms,
+          locales: localeSnaps.length >= 2 ? localeSnaps : undefined,
+        });
+      }
+      if (feats.length > 0) return feats;
+    }
+    // Mobile project but no per-OS result files yet → fall through to the base
+    // (locale-axis) path so the test CASES still render.
+  }
+
+  // -- Web / i18n (locale axis): one FeatureSnapshot; variants become locales[]. --
+  const locales: LocaleSnapshot[] = [];
+  let baseBuilt: Built | { scenarios: ScenarioSnapshot[]; summary: ScreenSummaryStats; featureName: string; featurePath?: string; specLink?: string } | null = null;
 
+  for (const variant of variants) {
+    const built = buildVariant(variant);
     locales.push({
       locale: variant.locale,
       displayCode: variant.displayCode,
       summary: built.summary,
       scenarios: built.scenarios,
     });
-
-    if (variant.locale === '') {
-      baseBuilt = built;
-    }
+    if (variant.locale === '') baseBuilt = built;
   }
 
   // Guarantee a base entry — every feature in the dashboard must have
@@ -227,9 +300,9 @@ function buildOneFeature(
       specLink,
     };
   }
-  if (!baseBuilt) return null;
+  if (!baseBuilt) return [];
 
-  return {
+  return [{
     featureBaseName,
     featureName: baseBuilt.featureName,
     featurePath: baseBuilt.featurePath,
@@ -239,7 +312,7 @@ function buildOneFeature(
     // Only expose `locales` array when 2+ variants exist — single-locale
     // features stay slimmer and UI can skip the locale tab UI entirely.
     locales: locales.length >= 2 ? locales : undefined,
-  };
+  }];
 }
 
 /**