pandora-cli-skills 1.1.50 → 1.1.52

package/README.md

@@ -73,6 +73,16 @@ pandora --output json lifecycle status --id <lifecycle-id>
 pandora --output json lifecycle resolve --id <lifecycle-id> --confirm
 ```
 
+### Mega Analytics Page (Dune Panels)
+
+```bash
+# starts local page at http://127.0.0.1:8787
+npm run analytics:mega
+```
+
+- Panel registry source: `analytics/dune/panel_registry.json`
+- Dashboard creation script reuses this registry: `scripts/create_pandora_dashboard.js`
+
 ## Risk Controls
 
 - Inspect/engage panic lock:

package/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: pandora-cli-skills
 summary: Canonical skill and operator guide for Pandora CLI including mirror, polymarket, resolve, and LP flows.
-version: 1.1.50
+version: 1.1.52
 ---
 
 # Pandora CLI & Skills

package/cli/lib/mirror_command_service.cjs

@@ -91,7 +91,7 @@ function createRunMirrorCommand(deps) {
         console.log('');
         console.log('Subcommands:');
         console.log(
-          '  browse --min-yes-pct <n> --max-yes-pct <n> --min-volume-24h <n> [--closes-after <date>] [--closes-before <date>] [--question-contains <text>] [--limit <n>] [--chain-id <id>] [--polymarket-tag-id <id>] [--polymarket-tag-ids <csv>] [--sport-tag-id <id>] [--sport-tag-ids <csv>] [--polymarket-gamma-url <url>] [--polymarket-gamma-mock-url <url>] [--polymarket-mock-url <url>]',
+          '  browse --min-yes-pct <n> --max-yes-pct <n> --min-volume-24h <n> [--closes-after <date>|--end-date-after <date|72h>] [--closes-before <date>|--end-date-before <date|72h>] [--question-contains <text>|--keyword <text>] [--slug <text>] [--category sports|crypto|politics|entertainment] [--exclude-sports] [--sort-by volume24h|liquidity|endDate] [--limit <n>] [--chain-id <id>] [--polymarket-tag-id <id>] [--polymarket-tag-ids <csv>] [--sport-tag-id <id>] [--sport-tag-ids <csv>] [--polymarket-gamma-url <url>] [--polymarket-gamma-mock-url <url>] [--polymarket-mock-url <url>]',
         );
         console.log(
           '  plan   --source polymarket --polymarket-market-id <id>|--polymarket-slug <slug> [--chain-id <id>] [--target-slippage-bps <n>] [--turnover-target <n>] [--depth-slippage-bps <n>] [--safety-multiplier <n>] [--min-liquidity-usdc <n>] [--max-liquidity-usdc <n>] [--with-rules] [--include-similarity] [--polymarket-gamma-url <url>] [--polymarket-gamma-mock-url <url>] [--polymarket-mock-url <url>]',

package/cli/lib/mirror_handlers/browse.cjs

@@ -22,12 +22,12 @@ module.exports = async function handleMirrorBrowse({ shared, context, deps }) {
         context.outputMode,
         'mirror.browse.help',
         commandHelpPayload(
-          'pandora [--output table|json] mirror browse [--min-yes-pct <n>] [--max-yes-pct <n>] [--min-volume-24h <n>] [--closes-after <date>] [--closes-before <date>] [--question-contains <text>] [--limit <n>] [--polymarket-tag-id <id>] [--polymarket-tag-ids <csv>] [--sport-tag-id <id>] [--sport-tag-ids <csv>]',
+          'pandora [--output table|json] mirror browse [--min-yes-pct <n>] [--max-yes-pct <n>] [--min-volume-24h <n>] [--closes-after <date>|--end-date-after <date|72h>] [--closes-before <date>|--end-date-before <date|72h>] [--question-contains <text>|--keyword <text>] [--slug <text>] [--category sports|crypto|politics|entertainment] [--exclude-sports] [--sort-by volume24h|liquidity|endDate] [--limit <n>] [--polymarket-tag-id <id>] [--polymarket-tag-ids <csv>] [--sport-tag-id <id>] [--sport-tag-ids <csv>]',
         ),
       );
     } else {
       console.log(
-        'Usage: pandora [--output table|json] mirror browse [--min-yes-pct <n>] [--max-yes-pct <n>] [--min-volume-24h <n>] [--closes-after <date>] [--closes-before <date>] [--question-contains <text>] [--limit <n>] [--polymarket-tag-id <id>] [--polymarket-tag-ids <csv>] [--sport-tag-id <id>] [--sport-tag-ids <csv>]',
+        'Usage: pandora [--output table|json] mirror browse [--min-yes-pct <n>] [--max-yes-pct <n>] [--min-volume-24h <n>] [--closes-after <date>|--end-date-after <date|72h>] [--closes-before <date>|--end-date-before <date|72h>] [--question-contains <text>|--keyword <text>] [--slug <text>] [--category sports|crypto|politics|entertainment] [--exclude-sports] [--sort-by volume24h|liquidity|endDate] [--limit <n>] [--polymarket-tag-id <id>] [--polymarket-tag-ids <csv>] [--sport-tag-id <id>] [--sport-tag-ids <csv>]',
       );
     }
     return;

package/cli/lib/mirror_service.cjs

@@ -413,6 +413,11 @@ async function browseMirrorMarkets(options = {}) {
     closesAfter: options.closesAfter,
     closesBefore: options.closesBefore,
     questionContains: options.questionContains,
+    keyword: options.keyword,
+    slug: options.slug,
+    categories: Array.isArray(options.categories) ? options.categories : [],
+    excludeSports: Boolean(options.excludeSports),
+    sortBy: options.sortBy,
     limit: options.limit,
   });
 

package/cli/lib/mirror_sync_service.cjs

@@ -102,82 +102,143 @@ async function runMirrorSync(options, deps = {}) {
         break;
       }
 
-      resetDailyCountersIfNeeded(state, tickAt);
-
-      const verifyPayload =
-        iteration === 1 && startupVerifyPayload
-          ? startupVerifyPayload
-          : await verifyFn(buildVerifyRequest(options));
-
-      const snapshotMetrics = evaluateSnapshot(verifyPayload, options);
-      const plan = buildTickPlan({
-        snapshotMetrics,
-        state,
-        options,
-      });
-      const depth = await fetchDepthSnapshot({
-        depthFn,
-        verifyPayload,
-        options,
-      });
-
-      const gate = applyGateBypassPolicy(
-        evaluateStrictGates(
-          buildTickGateContext({
-            verifyPayload,
+      try {
+        resetDailyCountersIfNeeded(state, tickAt);
+
+        const verifyPayload =
+          iteration === 1 && startupVerifyPayload
+            ? startupVerifyPayload
+            : await verifyFn(buildVerifyRequest(options));
+
+        const snapshotMetrics = evaluateSnapshot(verifyPayload, options);
+        const plan = buildTickPlan({
+          snapshotMetrics,
+          state,
+          options,
+        });
+        const depth = await fetchDepthSnapshot({
+          depthFn,
+          verifyPayload,
+          options,
+        });
+
+        const gate = applyGateBypassPolicy(
+          evaluateStrictGates(
+            buildTickGateContext({
+              verifyPayload,
+              options,
+              state,
+              plan,
+              snapshotMetrics,
+              depth,
+              minimumTimeToCloseSec,
+            }),
+          ),
+          options,
+        );
+
+        const snapshot = buildTickSnapshot({
+          iteration,
+          tickAt,
+          verifyPayload,
+          options,
+          snapshotMetrics,
+          plan,
+          depth,
+          gate,
+        });
+
+        if (snapshotMetrics.driftTriggered || plan.hedgeTriggered) {
+          await processTriggeredAction({
             options,
             state,
+            snapshot,
             plan,
+            gate,
+            tickAt,
+            loadedFilePath: loaded.filePath,
+            rebalanceFn,
+            hedgeFn,
+            sendWebhook,
+            strategyHash: hash,
+            iteration,
+            actions,
+            webhookReports,
             snapshotMetrics,
+            verifyPayload,
             depth,
-            minimumTimeToCloseSec,
-          }),
-        ),
-        options,
-      );
-
-      const snapshot = buildTickSnapshot({
-        iteration,
-        tickAt,
-        verifyPayload,
-        options,
-        snapshotMetrics,
-        plan,
-        depth,
-        gate,
-      });
-
-      if (snapshotMetrics.driftTriggered || plan.hedgeTriggered) {
-        await processTriggeredAction({
-          options,
+          });
+        }
+
+        await persistTickSnapshot({
+          loadedFilePath: loaded.filePath,
           state,
-          snapshot,
-          plan,
-          gate,
           tickAt,
+          snapshot,
+          snapshots,
+          onTick,
+          iteration,
+        });
+      } catch (err) {
+        const errorCode = err && err.code ? String(err.code) : 'MIRROR_SYNC_TICK_FAILED';
+        const errorMessage = err && err.message ? err.message : String(err);
+        const errorDetails = err && err.details !== undefined ? err.details : null;
+        const timestamp = tickAt.toISOString();
+
+        const diagnostic = {
+          level: 'error',
+          scope: 'tick',
+          iteration,
+          timestamp,
+          code: errorCode,
+          message: errorMessage,
+          retryable: options.mode !== 'once',
+        };
+        if (errorDetails !== null) diagnostic.details = errorDetails;
+        diagnostics.push(diagnostic);
+
+        const snapshot = {
+          schemaVersion: MIRROR_SYNC_SCHEMA_VERSION,
+          timestamp,
+          iteration,
+          metrics: {
+            driftBps: null,
+            plannedRebalanceUsdc: 0,
+            plannedHedgeUsdc: 0,
+          },
+          strictGate: {
+            ok: false,
+            failedChecks: [],
+            checks: [],
+          },
+          action: {
+            status: 'error',
+            failedChecks: [],
+            forcedGateBypass: false,
+            errorCode,
+            errorMessage,
+          },
+          error: {
+            code: errorCode,
+            message: errorMessage,
+            details: errorDetails,
+          },
+        };
+
+        await persistTickSnapshot({
           loadedFilePath: loaded.filePath,
-          rebalanceFn,
-          hedgeFn,
-          sendWebhook,
-          strategyHash: hash,
+          state,
+          tickAt,
+          snapshot,
+          snapshots,
+          onTick,
           iteration,
-          actions,
-          webhookReports,
-          snapshotMetrics,
-          verifyPayload,
-          depth,
         });
-      }
 
-      await persistTickSnapshot({
-        loadedFilePath: loaded.filePath,
-        state,
-        tickAt,
-        snapshot,
-        snapshots,
-        onTick,
-        iteration,
-      });
+        if (options.mode === 'once') {
+          throw err;
+        }
+      }
 
       if (shouldStop) break;
       if (iteration >= maxIterations) break;

package/cli/lib/parsers/mirror_remaining_flags.cjs

@@ -25,6 +25,71 @@ function createParseMirrorBrowseFlags(deps) {
   const parseDateLikeFlag = requireDep(deps, 'parseDateLikeFlag');
   const parsePositiveInteger = requireDep(deps, 'parsePositiveInteger');
   const parseInteger = requireDep(deps, 'parseInteger');
+  const allowedSortBy = new Set(['volume24h', 'liquidity', 'endDate']);
+  const allowedCategories = new Set(['sports', 'crypto', 'politics', 'entertainment']);
+
+  function parseBrowseWindowValue(value, flagName) {
+    const text = String(value || '').trim();
+    const relativeMatch = /^([1-9]\d*)([smhdw])$/i.exec(text);
+    if (relativeMatch) {
+      const quantity = Number(relativeMatch[1]);
+      const unit = String(relativeMatch[2] || '').toLowerCase();
+      const unitMs = {
+        s: 1000,
+        m: 60 * 1000,
+        h: 60 * 60 * 1000,
+        d: 24 * 60 * 60 * 1000,
+        w: 7 * 24 * 60 * 60 * 1000,
+      };
+      const multiplier = unitMs[unit];
+      if (!multiplier) {
+        throw new CliError(
+          'INVALID_FLAG_VALUE',
+          `${flagName} relative window must use one of s|m|h|d|w (example: 72h). Received: "${text}"`,
+        );
+      }
+      return new Date(Date.now() + quantity * multiplier).toISOString();
+    }
+    return parseDateLikeFlag(text, flagName);
+  }
+
+  function parseSortBy(rawValue) {
+    const text = String(rawValue || '').trim().toLowerCase();
+    if (!text) {
+      throw new CliError('INVALID_FLAG_VALUE', '--sort-by requires a value: volume24h|liquidity|endDate.');
+    }
+    if (text === 'volume' || text === 'volume24h' || text === 'volume24husd') return 'volume24h';
+    if (text === 'liquidity' || text === 'liquidityusd') return 'liquidity';
+    if (text === 'enddate' || text === 'end-date' || text === 'close' || text === 'close-time' || text === 'closetimestamp') {
+      return 'endDate';
+    }
+    throw new CliError(
+      'INVALID_FLAG_VALUE',
+      `--sort-by must be one of volume24h|liquidity|endDate. Received: "${rawValue}"`,
+    );
+  }
+
+  function parseCategoryList(rawValue, flagName) {
+    const values = String(rawValue || '')
+      .split(',')
+      .map((value) => value.trim().toLowerCase())
+      .filter(Boolean);
+    if (!values.length) {
+      throw new CliError(
+        'INVALID_FLAG_VALUE',
+        `${flagName} must include at least one category: sports|crypto|politics|entertainment.`,
+      );
+    }
+    for (const value of values) {
+      if (!allowedCategories.has(value)) {
+        throw new CliError(
+          'INVALID_FLAG_VALUE',
+          `${flagName} contains unsupported category "${value}". Allowed: sports|crypto|politics|entertainment.`,
+        );
+      }
+    }
+    return Array.from(new Set(values));
+  }
 
   return function parseMirrorBrowseFlags(args) {
     const options = {
@@ -40,6 +105,11 @@ function createParseMirrorBrowseFlags(deps) {
       polymarketGammaMockUrl: null,
       polymarketMockUrl: null,
       polymarketTagIds: [],
+      categories: [],
+      excludeSports: false,
+      sortBy: 'volume24h',
+      keyword: null,
+      slug: null,
     };
 
     function pushTagId(rawValue, flagName) {
@@ -63,13 +133,13 @@ function createParseMirrorBrowseFlags(deps) {
         i += 1;
         continue;
       }
-      if (token === '--closes-after') {
-        options.closesAfter = parseDateLikeFlag(requireFlagValue(args, i, '--closes-after'), '--closes-after');
+      if (token === '--closes-after' || token === '--end-date-after') {
+        options.closesAfter = parseBrowseWindowValue(requireFlagValue(args, i, token), token);
         i += 1;
         continue;
       }
-      if (token === '--closes-before') {
-        options.closesBefore = parseDateLikeFlag(requireFlagValue(args, i, '--closes-before'), '--closes-before');
+      if (token === '--closes-before' || token === '--end-date-before') {
+        options.closesBefore = parseBrowseWindowValue(requireFlagValue(args, i, token), token);
         i += 1;
         continue;
       }
@@ -78,11 +148,36 @@ function createParseMirrorBrowseFlags(deps) {
         i += 1;
         continue;
       }
+      if (token === '--keyword') {
+        options.keyword = requireFlagValue(args, i, '--keyword');
+        i += 1;
+        continue;
+      }
+      if (token === '--slug') {
+        options.slug = requireFlagValue(args, i, '--slug');
+        i += 1;
+        continue;
+      }
       if (token === '--limit') {
         options.limit = parsePositiveInteger(requireFlagValue(args, i, '--limit'), '--limit');
         i += 1;
         continue;
       }
+      if (token === '--sort-by') {
+        options.sortBy = parseSortBy(requireFlagValue(args, i, '--sort-by'));
+        i += 1;
+        continue;
+      }
+      if (token === '--category') {
+        const parsed = parseCategoryList(requireFlagValue(args, i, '--category'), '--category');
+        options.categories = Array.from(new Set(options.categories.concat(parsed)));
+        i += 1;
+        continue;
+      }
+      if (token === '--exclude-sports') {
+        options.excludeSports = true;
+        continue;
+      }
       if (token === '--chain-id') {
         options.chainId = parseInteger(requireFlagValue(args, i, '--chain-id'), '--chain-id');
         i += 1;
@@ -129,10 +224,28 @@ function createParseMirrorBrowseFlags(deps) {
     if (options.minYesPct !== null && options.maxYesPct !== null && options.minYesPct > options.maxYesPct) {
       throw new CliError('INVALID_ARGS', '--min-yes-pct cannot be greater than --max-yes-pct.');
     }
+    if (
+      options.closesAfter &&
+      options.closesBefore &&
+      Number.isFinite(Date.parse(options.closesAfter)) &&
+      Number.isFinite(Date.parse(options.closesBefore)) &&
+      Date.parse(options.closesAfter) > Date.parse(options.closesBefore)
+    ) {
+      throw new CliError('INVALID_ARGS', '--closes-after/--end-date-after cannot be later than --closes-before/--end-date-before.');
+    }
+    if (options.excludeSports && options.categories.includes('sports')) {
+      throw new CliError('INVALID_ARGS', '--exclude-sports cannot be combined with --category sports.');
+    }
 
     if (options.polymarketTagIds.length) {
       options.polymarketTagIds = Array.from(new Set(options.polymarketTagIds));
     }
+    if (options.categories.length) {
+      options.categories = Array.from(new Set(options.categories));
+    }
+    if (allowedSortBy.has(options.sortBy) !== true) {
+      throw new CliError('INVALID_FLAG_VALUE', `Unsupported --sort-by value: "${options.sortBy}"`);
+    }
 
     return options;
   };

package/cli/lib/polymarket_trade_adapter.cjs

@@ -616,6 +616,184 @@ function normalizeTagIdList(input) {
   return Array.from(new Set(normalized));
 }
 
+const BROWSE_ALLOWED_CATEGORIES = new Set(['sports', 'crypto', 'politics', 'entertainment']);
+const BROWSE_DEFAULT_SPORT_TAG_IDS = Object.freeze([82, 100350]);
+const BROWSE_SPORT_KEYWORDS = [
+  'sport',
+  'soccer',
+  'football',
+  'premier league',
+  'epl',
+  'nba',
+  'nfl',
+  'nhl',
+  'mlb',
+  'tennis',
+  'cricket',
+  'mma',
+  'ufc',
+  'formula 1',
+  'f1',
+];
+const BROWSE_CRYPTO_KEYWORDS = [
+  'crypto',
+  'bitcoin',
+  'btc',
+  'ethereum',
+  'eth',
+  'solana',
+  'defi',
+  'blockchain',
+  'altcoin',
+  'memecoin',
+];
+const BROWSE_POLITICS_KEYWORDS = [
+  'politic',
+  'election',
+  'president',
+  'prime minister',
+  'senate',
+  'congress',
+  'government',
+  'parliament',
+  'campaign',
+];
+const BROWSE_ENTERTAINMENT_KEYWORDS = [
+  'entertain',
+  'movie',
+  'film',
+  'music',
+  'album',
+  'artist',
+  'tv',
+  'celebrity',
+  'oscar',
+  'emmy',
+  'grammy',
+  'box office',
+];
+
+function normalizeBrowseCategoryList(input) {
+  const values = Array.isArray(input) ? input : [input];
+  const normalized = [];
+  for (const value of values) {
+    const text = String(value || '').trim().toLowerCase();
+    if (!text || !BROWSE_ALLOWED_CATEGORIES.has(text)) continue;
+    normalized.push(text);
+  }
+  return Array.from(new Set(normalized));
+}
+
+function normalizeBrowseSortBy(value) {
+  const text = String(value || '').trim().toLowerCase();
+  if (!text || text === 'volume24h' || text === 'volume24husd' || text === 'volume') return 'volume24h';
+  if (text === 'liquidity' || text === 'liquidityusd') return 'liquidity';
+  if (text === 'enddate' || text === 'end-date' || text === 'close' || text === 'close-time' || text === 'closetimestamp') {
+    return 'endDate';
+  }
+  return 'volume24h';
+}
+
+function collectTagEntries(row) {
+  const entries = [];
+  const eventTags = row && Array.isArray(row.event_tags) ? row.event_tags : [];
+  const directTags = row && Array.isArray(row.tags) ? row.tags : [];
+  entries.push(...eventTags);
+  entries.push(...directTags);
+  if (row && row.tag_id !== undefined) entries.push({ id: row.tag_id });
+  if (row && row.tagId !== undefined) entries.push({ id: row.tagId });
+  return entries;
+}
+
+function readTagId(tag) {
+  if (tag === null || tag === undefined) return null;
+  if (typeof tag === 'number' && Number.isFinite(tag)) {
+    const asInt = Math.trunc(tag);
+    return asInt > 0 ? asInt : null;
+  }
+  if (typeof tag === 'string' && /^\d+$/.test(tag.trim())) {
+    const asInt = Math.trunc(Number(tag.trim()));
+    return asInt > 0 ? asInt : null;
+  }
+  if (typeof tag === 'object') {
+    const candidate = tag.id !== undefined ? tag.id : tag.tag_id !== undefined ? tag.tag_id : tag.tagId;
+    return readTagId(candidate);
+  }
+  return null;
+}
+
+function readTagTextValues(tag) {
+  if (tag === null || tag === undefined) return [];
+  if (typeof tag === 'string') return [tag];
+  if (typeof tag === 'number') return [String(tag)];
+  if (typeof tag !== 'object') return [];
+  return [
+    tag.slug,
+    tag.name,
+    tag.label,
+    tag.title,
+    tag.group,
+    tag.topic,
+    tag.category,
+    tag.shortName,
+    tag.short_name,
+  ]
+    .map((value) => String(value || '').trim())
+    .filter(Boolean);
+}
+
+function includesKeyword(textPool, keywords) {
+  return textPool.some((text) => keywords.some((keyword) => text.includes(keyword)));
+}
+
+function classifyBrowseCategories(item) {
+  const row = item && item.raw && typeof item.raw === 'object' ? item.raw : {};
+  const tagEntries = collectTagEntries(row);
+  const tagIds = [];
+  const tagText = [];
+  const seenText = new Set();
+  const seenTagIds = new Set();
+
+  for (const entry of tagEntries) {
+    const tagId = readTagId(entry);
+    if (tagId !== null && !seenTagIds.has(tagId)) {
+      seenTagIds.add(tagId);
+      tagIds.push(tagId);
+    }
+    for (const text of readTagTextValues(entry)) {
+      const normalized = normalizeText(text);
+      if (!normalized || seenText.has(normalized)) continue;
+      seenText.add(normalized);
+      tagText.push(normalized);
+    }
+  }
+
+  const textPool = tagText.concat(
+    [item && item.eventTitle, item && item.eventSlug, item && item.slug, item && item.question]
+      .map((value) => normalizeText(value))
+      .filter(Boolean),
+  );
+
+  const categories = new Set();
+  if (tagIds.some((value) => BROWSE_DEFAULT_SPORT_TAG_IDS.includes(value)) || includesKeyword(textPool, BROWSE_SPORT_KEYWORDS)) {
+    categories.add('sports');
+  }
+  if (includesKeyword(textPool, BROWSE_CRYPTO_KEYWORDS)) {
+    categories.add('crypto');
+  }
+  if (includesKeyword(textPool, BROWSE_POLITICS_KEYWORDS)) {
+    categories.add('politics');
+  }
+  if (includesKeyword(textPool, BROWSE_ENTERTAINMENT_KEYWORDS)) {
+    categories.add('entertainment');
+  }
+
+  return {
+    categories: Array.from(categories),
+    tagIds,
+  };
+}
+
 async function fetchGammaRowsByTagIds(params, options = {}, diagnostics = []) {
   const timeoutMs = Number.isInteger(options.timeoutMs) && options.timeoutMs > 0 ? options.timeoutMs : 12_000;
   const gammaUrl = normalizeGammaBaseUrl(options.gammaUrl);
@@ -1132,7 +1310,13 @@ async function browsePolymarketMarkets(options = {}) {
   const timeoutMs = Number.isInteger(options.timeoutMs) && options.timeoutMs > 0 ? options.timeoutMs : 12_000;
   const requestedLimit = Number.isInteger(Number(options.limit)) && Number(options.limit) > 0 ? Number(options.limit) : 10;
   const scanLimit = Math.max(requestedLimit * 5, 100);
-  const polymarketTagIds = normalizeTagIdList(options.polymarketTagIds);
+  const requestedTagIds = normalizeTagIdList(options.polymarketTagIds);
+  const categoryFilters = normalizeBrowseCategoryList(options.categories);
+  const autoSportsTagIds = requestedTagIds.length === 0 && categoryFilters.includes('sports') ? [...BROWSE_DEFAULT_SPORT_TAG_IDS] : [];
+  const polymarketTagIds = requestedTagIds.length ? requestedTagIds : autoSportsTagIds;
+  if (autoSportsTagIds.length) {
+    diagnostics.push(`No explicit sports tag ids provided; using defaults: ${autoSportsTagIds.join(', ')}.`);
+  }
   const useSportsEventsEndpoint = polymarketTagIds.length > 0;
 
   let rows = [];
@@ -1172,20 +1356,86 @@ async function browsePolymarketMarkets(options = {}) {
   const closesAfter = toTimestampSeconds(options.closesAfter);
   const closesBefore = toTimestampSeconds(options.closesBefore);
   const questionContains = normalizeText(options.questionContains);
+  const keyword = normalizeText(options.keyword);
+  const slugContains = normalizeText(options.slug);
+  const excludeSports = Boolean(options.excludeSports);
+  const sortBy = normalizeBrowseSortBy(options.sortBy);
 
   const normalized = rows.map((row) => normalizeMarketRow(row));
-  const filtered = normalized.filter((item) => {
+  const enriched = normalized.map((item) => {
+    const classification = classifyBrowseCategories(item);
+    return {
+      ...item,
+      categories: classification.categories,
+      tagIds: classification.tagIds,
+    };
+  });
+
+  const filtered = enriched.filter((item) => {
     if (item.active === false || item.resolved) return false;
-    if (minYesPct !== null && toOptionalNumber(item.yesPct) !== null && toOptionalNumber(item.yesPct) < minYesPct) return false;
-    if (maxYesPct !== null && toOptionalNumber(item.yesPct) !== null && toOptionalNumber(item.yesPct) > maxYesPct) return false;
+    const yesPct = toOptionalNumber(item.yesPct);
+    if ((minYesPct !== null || maxYesPct !== null) && yesPct === null) return false;
+    if (minYesPct !== null && yesPct < minYesPct) return false;
+    if (maxYesPct !== null && yesPct > maxYesPct) return false;
     if ((toOptionalNumber(item.volume24hUsd) || 0) < minVolume24h) return false;
     if (closesAfter !== null && toIntegerOrNull(item.closeTimestamp) !== null && toIntegerOrNull(item.closeTimestamp) < closesAfter) return false;
     if (closesBefore !== null && toIntegerOrNull(item.closeTimestamp) !== null && toIntegerOrNull(item.closeTimestamp) > closesBefore) return false;
     if (questionContains && !normalizeText(item.question).includes(questionContains)) return false;
+    if (slugContains) {
+      const slugHaystack = [item.slug, item.eventSlug].map((value) => normalizeText(value)).filter(Boolean).join(' ');
+      if (!slugHaystack.includes(slugContains)) return false;
+    }
+    if (keyword) {
+      const keywordHaystack = [item.question, item.slug, item.eventSlug, item.eventTitle]
+        .map((value) => normalizeText(value))
+        .filter(Boolean)
+        .join(' ');
+      if (!keywordHaystack.includes(keyword)) return false;
+    }
+    if (excludeSports && Array.isArray(item.categories) && item.categories.includes('sports')) return false;
+    if (categoryFilters.length) {
+      const hasCategory = Array.isArray(item.categories) && item.categories.some((value) => categoryFilters.includes(value));
+      if (!hasCategory) return false;
+    }
     return true;
   });
 
-  filtered.sort((left, right) => (toOptionalNumber(right.volume24hUsd) || 0) - (toOptionalNumber(left.volume24hUsd) || 0));
+  filtered.sort((left, right) => {
+    const leftVolume = toOptionalNumber(left.volume24hUsd) || 0;
+    const rightVolume = toOptionalNumber(right.volume24hUsd) || 0;
+    const leftLiquidity = toOptionalNumber(left.liquidityUsd) || 0;
+    const rightLiquidity = toOptionalNumber(right.liquidityUsd) || 0;
+    const leftClose = toIntegerOrNull(left.closeTimestamp);
+    const rightClose = toIntegerOrNull(right.closeTimestamp);
+
+    if (sortBy === 'liquidity') {
+      if (rightLiquidity !== leftLiquidity) return rightLiquidity - leftLiquidity;
+      if (rightVolume !== leftVolume) return rightVolume - leftVolume;
+      if (leftClose === null && rightClose === null) return 0;
+      if (leftClose === null) return 1;
+      if (rightClose === null) return -1;
+      return leftClose - rightClose;
+    }
+
+    if (sortBy === 'endDate') {
+      if (leftClose === null && rightClose === null) {
+        if (rightVolume !== leftVolume) return rightVolume - leftVolume;
+        return rightLiquidity - leftLiquidity;
+      }
+      if (leftClose === null) return 1;
+      if (rightClose === null) return -1;
+      if (leftClose !== rightClose) return leftClose - rightClose;
+      if (rightVolume !== leftVolume) return rightVolume - leftVolume;
+      return rightLiquidity - leftLiquidity;
+    }
+
+    if (rightVolume !== leftVolume) return rightVolume - leftVolume;
+    if (rightLiquidity !== leftLiquidity) return rightLiquidity - leftLiquidity;
+    if (leftClose === null && rightClose === null) return 0;
+    if (leftClose === null) return 1;
+    if (rightClose === null) return -1;
+    return leftClose - rightClose;
+  });
 
   const items = filtered.slice(0, requestedLimit).map((item) => ({
     marketId: item.marketId,
@@ -1201,6 +1451,7 @@ async function browsePolymarketMarkets(options = {}) {
     liquidityUsd: round(item.liquidityUsd, 6),
     active: item.active,
     resolved: item.resolved,
+    categories: Array.isArray(item.categories) ? item.categories : [],
     url: item.url,
     sourceType: item.source || sourceType,
   }));
@@ -1219,6 +1470,11 @@ async function browsePolymarketMarkets(options = {}) {
       closesAfter,
       closesBefore,
       questionContains: options.questionContains || null,
+      keyword: options.keyword || null,
+      slug: options.slug || null,
+      categories: categoryFilters,
+      excludeSports,
+      sortBy,
       limit: requestedLimit,
       polymarketTagIds,
     },

package/cli/lib/schema_command_service.cjs

@@ -267,7 +267,7 @@ function buildCommandDescriptors() {
     'mirror.browse': commandDescriptor({
       summary: 'Browse Polymarket mirror candidates with optional sports tag filters.',
       usage:
-        'pandora [--output table|json] mirror browse [--min-yes-pct <n>] [--max-yes-pct <n>] [--min-volume-24h <n>] [--closes-after <date>] [--closes-before <date>] [--question-contains <text>] [--limit <n>] [--chain-id <id>] [--polymarket-tag-id <id>] [--polymarket-tag-ids <csv>] [--sport-tag-id <id>] [--sport-tag-ids <csv>] [--polymarket-gamma-url <url>] [--polymarket-gamma-mock-url <url>] [--polymarket-mock-url <url>]',
+        'pandora [--output table|json] mirror browse [--min-yes-pct <n>] [--max-yes-pct <n>] [--min-volume-24h <n>] [--closes-after <date>|--end-date-after <date|72h>] [--closes-before <date>|--end-date-before <date|72h>] [--question-contains <text>|--keyword <text>] [--slug <text>] [--category sports|crypto|politics|entertainment] [--exclude-sports] [--sort-by volume24h|liquidity|endDate] [--limit <n>] [--chain-id <id>] [--polymarket-tag-id <id>] [--polymarket-tag-ids <csv>] [--sport-tag-id <id>] [--sport-tag-ids <csv>] [--polymarket-gamma-url <url>] [--polymarket-gamma-mock-url <url>] [--polymarket-mock-url <url>]',
       emits: ['mirror.browse', 'mirror.browse.help'],
       dataSchema: '#/definitions/MirrorBrowsePayload',
     }),

package/cli/pandora.cjs

@@ -516,7 +516,11 @@ function getDoctorServiceInstance() {
 const ROOT = path.resolve(__dirname, '..');
 const DEFAULT_ENV_FILE_PRIMARY = path.join(ROOT, 'scripts', '.env');
 const DEFAULT_ENV_FILE_FALLBACK = path.join(os.homedir(), '.pandora-cli.env');
-const DEFAULT_ENV_FILE = fs.existsSync(DEFAULT_ENV_FILE_PRIMARY) ? DEFAULT_ENV_FILE_PRIMARY : DEFAULT_ENV_FILE_FALLBACK;
+const DEFAULT_ENV_FILE = fs.existsSync(DEFAULT_ENV_FILE_FALLBACK)
+  ? DEFAULT_ENV_FILE_FALLBACK
+  : fs.existsSync(DEFAULT_ENV_FILE_PRIMARY)
+    ? DEFAULT_ENV_FILE_PRIMARY
+    : DEFAULT_ENV_FILE_FALLBACK;
 const DEFAULT_ENV_EXAMPLE = path.join(ROOT, 'scripts', '.env.example');
 const DEFAULT_INDEXER_URL = SHARED_DEFAULT_INDEXER_URL;
 let PACKAGE_VERSION = '0.0.0';
@@ -855,7 +859,7 @@ Examples:
 
 Notes:
   - launch/clone-bet forward unknown flags directly to underlying scripts.
-  - Env auto-load default: scripts/.env when present; otherwise ~/.pandora-cli.env. Use --skip-dotenv to disable.
+  - Env auto-load default: ~/.pandora-cli.env when present; otherwise scripts/.env. Use --skip-dotenv to disable.
   - --output json is supported for all commands except launch/clone-bet.
   - Indexer URL resolution order: --indexer-url, PANDORA_INDEXER_URL, INDEXER_URL, default public indexer.
   - mirror status --with-live can enrich output with Polymarket position data when POLYMARKET_* credentials are set; missing endpoints/creds return diagnostics instead of hard failures.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pandora-cli-skills",
-  "version": "1.1.50",
+  "version": "1.1.52",
   "description": "Pandora CLI & Skills",
   "main": "cli/pandora.cjs",
   "bin": {
@@ -29,6 +29,7 @@
     "init-env": "node cli/pandora.cjs init-env",
     "doctor": "node cli/pandora.cjs doctor",
     "setup": "node cli/pandora.cjs setup",
+    "analytics:mega": "node analytics/dune/mega/server.cjs",
     "dry-run": "node cli/pandora.cjs launch --dry-run",
     "execute": "node cli/pandora.cjs launch --execute",
     "dry-run:clone": "node cli/pandora.cjs clone-bet --dry-run",
@@ -68,6 +69,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",
     "@polymarket/clob-client": "^5.2.4",
+    "playwright-core": "^1.58.2",
     "tsx": "^4.21.0",
     "viem": "^2.46.2",
     "ws": "^8.19.0"

package/tests/cli/cli.integration.test.cjs

@@ -5024,6 +5024,126 @@ test('mirror browse supports sports tag filters via gamma events endpoint', asyn
   }
 });
 
+test('mirror browse supports non-sports short-window filtering in one call', async () => {
+  const indexer = await startIndexerMockServer(buildMirrorIndexerOverrides());
+  const nowMs = Date.now();
+  const toIso = (offsetHours) => new Date(nowMs + offsetHours * 60 * 60 * 1000).toISOString();
+  const gamma = await startJsonHttpServer((request) => {
+    const parsed = new URL(request.url || '/', 'http://127.0.0.1');
+    if (parsed.pathname !== '/markets') {
+      return { status: 404, body: { error: 'not found' } };
+    }
+    return {
+      body: {
+        markets: [
+          {
+            condition_id: 's1',
+            market_slug: 'everton-v-burnley-home',
+            question: 'Will Everton beat Burnley?',
+            end_date_iso: toIso(24),
+            active: true,
+            closed: false,
+            volume24hr: 9000,
+            liquidity: 9000,
+            tags: [{ id: 82, slug: 'soccer' }],
+            tokens: [
+              { outcome: 'Yes', price: '0.61', token_id: 's1-yes' },
+              { outcome: 'No', price: '0.39', token_id: 's1-no' },
+            ],
+          },
+          {
+            condition_id: 'c1',
+            market_slug: 'bitcoin-etf-approval-2026',
+            question: 'Will bitcoin ETF approval happen in 2026?',
+            end_date_iso: toIso(36),
+            active: true,
+            closed: false,
+            volume24hr: 8000,
+            liquidity: 1000,
+            tags: [{ slug: 'crypto' }],
+            tokens: [
+              { outcome: 'Yes', price: '0.45', token_id: 'c1-yes' },
+              { outcome: 'No', price: '0.55', token_id: 'c1-no' },
+            ],
+          },
+          {
+            condition_id: 'c2',
+            market_slug: 'bitcoin-price-120k-2026',
+            question: 'Will bitcoin trade above 120k in 2026?',
+            end_date_iso: toIso(18),
+            active: true,
+            closed: false,
+            volume24hr: 2000,
+            liquidity: 7000,
+            tags: [{ slug: 'crypto' }],
+            tokens: [
+              { outcome: 'Yes', price: '0.55', token_id: 'c2-yes' },
+              { outcome: 'No', price: '0.45', token_id: 'c2-no' },
+            ],
+          },
+          {
+            condition_id: 'x1',
+            market_slug: 'bitcoin-over-300k',
+            question: 'Will bitcoin exceed 300k?',
+            end_date_iso: toIso(12),
+            active: true,
+            closed: false,
+            volume24hr: 10000,
+            liquidity: 1000,
+            tags: [{ slug: 'crypto' }],
+            tokens: [
+              { outcome: 'Yes', price: '0.95', token_id: 'x1-yes' },
+              { outcome: 'No', price: '0.05', token_id: 'x1-no' },
+            ],
+          },
+        ],
+      },
+    };
+  });
+
+  try {
+    const result = await runCliAsync([
+      '--output',
+      'json',
+      'mirror',
+      'browse',
+      '--skip-dotenv',
+      '--indexer-url',
+      indexer.url,
+      '--polymarket-gamma-url',
+      gamma.url,
+      '--exclude-sports',
+      '--end-date-before',
+      '72h',
+      '--min-yes-pct',
+      '15',
+      '--max-yes-pct',
+      '85',
+      '--sort-by',
+      'volume24h',
+      '--keyword',
+      'bitcoin',
+      '--limit',
+      '10',
+    ]);
+
+    assert.equal(result.status, 0);
+    const payload = parseJsonOutput(result);
+    assert.equal(payload.ok, true);
+    assert.equal(payload.command, 'mirror.browse');
+    assert.equal(payload.data.filters.excludeSports, true);
+    assert.equal(payload.data.filters.sortBy, 'volume24h');
+    assert.equal(payload.data.count, 2);
+    assert.equal(payload.data.items[0].slug, 'bitcoin-etf-approval-2026');
+    assert.equal(payload.data.items[1].slug, 'bitcoin-price-120k-2026');
+    assert.ok(Array.isArray(payload.data.items[0].categories));
+    assert.ok(payload.data.items[0].categories.includes('crypto'));
+  } finally {
+    await indexer.close();
+    await gamma.close();
+  }
+});
+
 test('mirror sync accepts --market-address with --dry-run mode alias', async () => {
   const tempDir = createTempDir('pandora-mirror-sync-aliases-');
   const stateFile = path.join(tempDir, 'mirror-state.json');

package/tests/unit/new-features.test.cjs

@@ -53,6 +53,7 @@ const { createParseWatchFlags } = require('../../cli/lib/parsers/watch_flags.cjs
 const { createParseAutopilotFlags } = require('../../cli/lib/parsers/autopilot_flags.cjs');
 const { createParseMirrorDeployFlags } = require('../../cli/lib/parsers/mirror_deploy_flags.cjs');
 const { createParseMirrorGoFlags } = require('../../cli/lib/parsers/mirror_go_flags.cjs');
+const { createParseMirrorBrowseFlags } = require('../../cli/lib/parsers/mirror_remaining_flags.cjs');
 const { createParseLifecycleFlags } = require('../../cli/lib/parsers/lifecycle_flags.cjs');
 const { createParseOddsFlags } = require('../../cli/lib/parsers/odds_flags.cjs');
 const {
@@ -165,6 +166,19 @@ function parserIsSecureHttpUrlOrLocal(value) {
   return /^https:\/\//.test(value) || /^http:\/\/(localhost|127\.0\.0\.1)(:\d+)?(\/|$)/.test(value);
 }
 
+function parserParseDateLikeFlag(value, flagName) {
+  const text = String(value || '').trim();
+  if (/^-?\d+(\.\d+)?$/.test(text)) {
+    throw new ParserCliError('INVALID_FLAG_VALUE', `${flagName} must be an ISO date/time string.`);
+  }
+  const normalized = /^\d{4}-\d{2}-\d{2}$/.test(text) ? `${text}T00:00:00Z` : text;
+  const parsed = Date.parse(normalized);
+  if (!Number.isFinite(parsed)) {
+    throw new ParserCliError('INVALID_FLAG_VALUE', `${flagName} must be an ISO date/time string.`);
+  }
+  return text;
+}
+
 function parserParseMirrorSyncGateSkipList(value, flagName) {
   const checks = String(value)
     .split(',')
@@ -1152,6 +1166,149 @@ test('browsePolymarketMarkets uses gamma events endpoint for tag-id sports disco
   }
 });
 
+test('browsePolymarketMarkets supports category/keyword/date filters with explicit sorting', async () => {
+  const nowMs = Date.now();
+  const toIso = (offsetHours) => new Date(nowMs + offsetHours * 60 * 60 * 1000).toISOString();
+
+  const server = http.createServer((req, res) => {
+    const parsed = new URL(req.url || '/', 'http://127.0.0.1');
+    res.statusCode = 200;
+    res.setHeader('content-type', 'application/json');
+    if (parsed.pathname !== '/markets') {
+      res.end(JSON.stringify({ markets: [] }));
+      return;
+    }
+
+    res.end(
+      JSON.stringify({
+        markets: [
+          {
+            condition_id: 'm-sports',
+            market_slug: 'everton-v-burnley-home',
+            question: 'Will Everton beat Burnley?',
+            end_date_iso: toIso(12),
+            active: true,
+            closed: false,
+            volume24hr: 9000,
+            liquidity: 9000,
+            tags: [{ id: 82, slug: 'soccer' }],
+            tokens: [
+              { outcome: 'Yes', price: '0.60', token_id: 'sports-yes' },
+              { outcome: 'No', price: '0.40', token_id: 'sports-no' },
+            ],
+          },
+          {
+            condition_id: 'm-crypto-high-vol',
+            market_slug: 'bitcoin-etf-approval-2026',
+            question: 'Will Bitcoin ETF approval happen in 2026?',
+            end_date_iso: toIso(24),
+            active: true,
+            closed: false,
+            volume24hr: 8000,
+            liquidity: 1000,
+            tags: [{ slug: 'crypto' }],
+            tokens: [
+              { outcome: 'Yes', price: '0.45', token_id: 'c1-yes' },
+              { outcome: 'No', price: '0.55', token_id: 'c1-no' },
+            ],
+          },
+          {
+            condition_id: 'm-crypto-high-liq',
+            market_slug: 'bitcoin-price-120k-2026',
+            question: 'Will bitcoin trade above 120k in 2026?',
+            end_date_iso: toIso(18),
+            active: true,
+            closed: false,
+            volume24hr: 2000,
+            liquidity: 7000,
+            tags: [{ slug: 'crypto' }],
+            tokens: [
+              { outcome: 'Yes', price: '0.55', token_id: 'c2-yes' },
+              { outcome: 'No', price: '0.45', token_id: 'c2-no' },
+            ],
+          },
+          {
+            condition_id: 'm-crypto-extreme',
+            market_slug: 'bitcoin-over-300k',
+            question: 'Will bitcoin exceed 300k?',
+            end_date_iso: toIso(10),
+            active: true,
+            closed: false,
+            volume24hr: 10000,
+            liquidity: 1000,
+            tags: [{ slug: 'crypto' }],
+            tokens: [
+              { outcome: 'Yes', price: '0.95', token_id: 'c3-yes' },
+              { outcome: 'No', price: '0.05', token_id: 'c3-no' },
+            ],
+          },
+          {
+            condition_id: 'm-crypto-far',
+            market_slug: 'bitcoin-long-dated',
+            question: 'Will bitcoin close above 200k by 2028?',
+            end_date_iso: toIso(120),
+            active: true,
+            closed: false,
+            volume24hr: 11000,
+            liquidity: 11000,
+            tags: [{ slug: 'crypto' }],
+            tokens: [
+              { outcome: 'Yes', price: '0.50', token_id: 'c4-yes' },
+              { outcome: 'No', price: '0.50', token_id: 'c4-no' },
+            ],
+          },
+        ],
+      }),
+    );
+  });
+
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const { port } = server.address();
+  const gammaUrl = `http://127.0.0.1:${port}`;
+
+  try {
+    const byVolume = await browsePolymarketMarkets({
+      gammaUrl,
+      minYesPct: 15,
+      maxYesPct: 85,
+      closesBefore: toIso(72),
+      keyword: 'bitcoin',
+      categories: ['crypto'],
+      excludeSports: true,
+      sortBy: 'volume24h',
+      limit: 10,
+    });
+
+    assert.equal(byVolume.count, 2);
+    assert.equal(byVolume.items[0].slug, 'bitcoin-etf-approval-2026');
+    assert.equal(byVolume.items[1].slug, 'bitcoin-price-120k-2026');
+    assert.ok(Array.isArray(byVolume.items[0].categories));
+    assert.ok(byVolume.items[0].categories.includes('crypto'));
+    assert.equal(byVolume.filters.excludeSports, true);
+    assert.deepEqual(byVolume.filters.categories, ['crypto']);
+    assert.equal(byVolume.filters.sortBy, 'volume24h');
+
+    const byLiquidity = await browsePolymarketMarkets({
+      gammaUrl,
+      minYesPct: 15,
+      maxYesPct: 85,
+      closesBefore: toIso(72),
+      keyword: 'bitcoin',
+      categories: ['crypto'],
+      excludeSports: true,
+      sortBy: 'liquidity',
+      limit: 10,
+    });
+
+    assert.equal(byLiquidity.count, 2);
+    assert.equal(byLiquidity.items[0].slug, 'bitcoin-price-120k-2026');
+    assert.equal(byLiquidity.items[1].slug, 'bitcoin-etf-approval-2026');
+    assert.equal(byLiquidity.filters.sortBy, 'liquidity');
+  } finally {
+    await new Promise((resolve) => server.close(resolve));
+  }
+});
+
 test('computeApprovalDiff deterministically marks missing allowance/operator checks', () => {
   const payload = computeApprovalDiff({
     ownerAddress: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
@@ -1493,6 +1650,165 @@ test('runMirrorSync handles thrown hedgeFn errors without consuming idempotency'
   }
 });
 
+test('runMirrorSync run mode continues after transient tick verification failures', async () => {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pandora-mirror-sync-tick-retry-'));
+  const stateFile = path.join(tempDir, 'mirror-state.json');
+  const killSwitchFile = path.join(tempDir, 'STOP');
+
+  const verifyPayload = {
+    matchConfidence: 0.99,
+    gateResult: {
+      ok: true,
+      failedChecks: [],
+      checks: [{ code: 'CLOSE_TIME_DELTA', ok: true, meta: { closeDeltaHours: 0 } }],
+    },
+    sourceMarket: {
+      source: 'polymarket',
+      marketId: 'poly-cond-1',
+      yesPct: 60,
+      yesTokenId: 'yes-token',
+      noTokenId: 'no-token',
+    },
+    pandora: {
+      yesPct: 55,
+      reserveYes: 5,
+      reserveNo: 5,
+    },
+    expiry: { minTimeToExpirySec: 7200 },
+  };
+
+  let verifyCallCount = 0;
+
+  try {
+    const payload = await runMirrorSync(
+      {
+        mode: 'run',
+        iterations: 3,
+        indexerUrl: 'https://example.invalid/graphql',
+        timeoutMs: 1000,
+        pandoraMarketAddress: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+        polymarketMarketId: 'poly-cond-1',
+        executeLive: false,
+        trustDeploy: false,
+        hedgeEnabled: false,
+        hedgeRatio: 1,
+        intervalMs: 1,
+        driftTriggerBps: 10000,
+        hedgeTriggerUsdc: 1000,
+        maxRebalanceUsdc: 25,
+        maxHedgeUsdc: 10,
+        maxOpenExposureUsdc: 100,
+        maxTradesPerDay: 10,
+        cooldownMs: 1000,
+        depthSlippageBps: 100,
+        stateFile,
+        killSwitchFile,
+        polymarketHost: 'https://clob.polymarket.com',
+      },
+      {
+        verifyFn: async () => {
+          verifyCallCount += 1;
+          if (verifyCallCount === 2) {
+            const error = new Error('temporary indexer timeout');
+            error.code = 'INDEXER_TIMEOUT';
+            throw error;
+          }
+          return verifyPayload;
+        },
+        depthFn: async () => ({
+          depthWithinSlippageUsd: 1000,
+          yesDepth: { depthUsd: 1000, midPrice: 0.4, worstPrice: 0.41 },
+          noDepth: { depthUsd: 1000, midPrice: 0.6, worstPrice: 0.61 },
+        }),
+        sleep: async () => {},
+      },
+    );
+
+    assert.equal(payload.iterationsCompleted, 3);
+    assert.equal(payload.snapshots.length, 3);
+    assert.equal(payload.diagnostics.length, 1);
+    assert.equal(payload.diagnostics[0].code, 'INDEXER_TIMEOUT');
+    assert.equal(payload.diagnostics[0].scope, 'tick');
+    assert.equal(payload.snapshots[1].action.status, 'error');
+    assert.equal(payload.snapshots[1].error.code, 'INDEXER_TIMEOUT');
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('runMirrorSync once mode still fails fast on tick errors', async () => {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pandora-mirror-sync-once-fail-'));
+  const stateFile = path.join(tempDir, 'mirror-state.json');
+  const killSwitchFile = path.join(tempDir, 'STOP');
+
+  const verifyPayload = {
+    matchConfidence: 0.99,
+    gateResult: {
+      ok: true,
+      failedChecks: [],
+      checks: [{ code: 'CLOSE_TIME_DELTA', ok: true, meta: { closeDeltaHours: 0 } }],
+    },
+    sourceMarket: {
+      source: 'polymarket',
+      marketId: 'poly-cond-1',
+      yesPct: 60,
+      yesTokenId: 'yes-token',
+      noTokenId: 'no-token',
+    },
+    pandora: {
+      yesPct: 55,
+      reserveYes: 5,
+      reserveNo: 5,
+    },
+    expiry: { minTimeToExpirySec: 7200 },
+  };
+
+  try {
+    await assert.rejects(
+      runMirrorSync(
+        {
+          mode: 'once',
+          indexerUrl: 'https://example.invalid/graphql',
+          timeoutMs: 1000,
+          pandoraMarketAddress: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+          polymarketMarketId: 'poly-cond-1',
+          executeLive: false,
+          trustDeploy: false,
+          hedgeEnabled: false,
+          hedgeRatio: 1,
+          intervalMs: 1,
+          driftTriggerBps: 10000,
+          hedgeTriggerUsdc: 1000,
+          maxRebalanceUsdc: 25,
+          maxHedgeUsdc: 10,
+          maxOpenExposureUsdc: 100,
+          maxTradesPerDay: 10,
+          cooldownMs: 1000,
+          depthSlippageBps: 100,
+          stateFile,
+          killSwitchFile,
+          polymarketHost: 'https://clob.polymarket.com',
+        },
+        {
+          verifyFn: async () => verifyPayload,
+          depthFn: async () => {
+            const error = new Error('depth fetch unavailable');
+            error.code = 'DEPTH_FETCH_FAILED';
+            throw error;
+          },
+          sleep: async () => {},
+        },
+      ),
+      (error) => {
+        assert.equal(error.code, 'DEPTH_FETCH_FAILED');
+        return true;
+      },
+    );
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
 test('runAutopilot does not consume budget/idempotency when executeFn throws', async () => {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pandora-autopilot-failure-'));
   const stateFile = path.join(tempDir, 'autopilot-state.json');
@@ -1623,6 +1939,59 @@ test('createParseTradeFlags enforces secure --rpc-url and drops dead funder fiel
   );
 });
 
+test('createParseMirrorBrowseFlags parses relative end-date windows and new browse selectors', () => {
+  const parseMirrorBrowseFlags = createParseMirrorBrowseFlags(
+    buildParserDeps({
+      parseDateLikeFlag: parserParseDateLikeFlag,
+    }),
+  );
+
+  const startedAt = Date.now();
+  const options = parseMirrorBrowseFlags([
+    '--end-date-after',
+    '1h',
+    '--end-date-before',
+    '72h',
+    '--keyword',
+    'bitcoin',
+    '--slug',
+    'etf',
+    '--category',
+    'crypto,politics',
+    '--sort-by',
+    'liquidity',
+    '--limit',
+    '7',
+  ]);
+
+  assert.equal(options.keyword, 'bitcoin');
+  assert.equal(options.slug, 'etf');
+  assert.deepEqual(options.categories, ['crypto', 'politics']);
+  assert.equal(options.sortBy, 'liquidity');
+  assert.equal(options.limit, 7);
+  assert.ok(Number.isFinite(Date.parse(options.closesAfter)));
+  assert.ok(Number.isFinite(Date.parse(options.closesBefore)));
+  assert.ok(Date.parse(options.closesAfter) >= startedAt + 45 * 60 * 1000);
+  assert.ok(Date.parse(options.closesBefore) >= startedAt + 70 * 60 * 60 * 1000);
+});
+
+test('createParseMirrorBrowseFlags rejects contradictory sports filters', () => {
+  const parseMirrorBrowseFlags = createParseMirrorBrowseFlags(
+    buildParserDeps({
+      parseDateLikeFlag: parserParseDateLikeFlag,
+    }),
+  );
+
+  assert.throws(
+    () => parseMirrorBrowseFlags(['--category', 'sports', '--exclude-sports']),
+    (error) => {
+      assert.equal(error.code, 'INVALID_ARGS');
+      assert.match(error.message, /cannot be combined/i);
+      return true;
+    },
+  );
+});
+
 test('resolveForkRuntime supports attach-only fork mode with strict env/flag precedence', () => {
   const live = resolveForkRuntime(
     { chainId: 146 },