pandora-cli-skills 1.1.7 → 1.1.9

package/README_FOR_SHARING.md

@@ -90,7 +90,7 @@ Prerequisite: Node.js `>=18`.
   - `pandora export --wallet <0x...> --format csv --year 2026 --out ./trades-2026.csv`
   - `pandora arbitrage --venues pandora,polymarket --min-spread-pct 3`
   - `pandora autopilot run|once ...`
-  - `pandora mirror plan|deploy|verify|sync|status ...`
+  - `pandora mirror browse|plan|deploy|verify|go|sync|status|close ...`
   - `pandora webhook test ...`
   - `pandora leaderboard --metric profit|volume|win-rate`
   - `pandora analyze --market-address <0x...> --provider <name>`
@@ -113,10 +113,13 @@ Prerequisite: Node.js `>=18`.
 - `pandora export --wallet <0x...> --format csv --out ./trades.csv`
 - `pandora arbitrage --venues pandora,polymarket --min-spread-pct 2 --cross-venue-only --with-rules --include-similarity`
 - `pandora autopilot once --market-address <0x...> --side no --amount-usdc 10 --trigger-yes-below 15 --paper`
+- `pandora mirror browse --min-yes-pct 20 --max-yes-pct 80 --min-volume-24h 100000 --limit 10`
 - `pandora mirror plan --source polymarket --polymarket-market-id <id> --with-rules --include-similarity`
+- `pandora mirror go --polymarket-slug <slug> --liquidity-usdc 10 --paper`
 - `pandora mirror verify --pandora-market-address <0x...> --polymarket-market-id <id> --include-similarity`
 - `pandora mirror sync once --pandora-market-address <0x...> --polymarket-market-id <id> --paper --hedge-ratio 1.0`
-- `pandora mirror status --strategy-hash <hash>`
+- `pandora mirror status --strategy-hash <hash> --with-live`
+- `pandora mirror close --pandora-market-address <0x...> --polymarket-market-id <id> --dry-run`
 - `pandora webhook test --webhook-url https://example.com/hook`
 - `pandora leaderboard --metric volume --limit 20`
 - `pandora analyze --market-address <0x...> --provider mock`
@@ -188,17 +191,25 @@ Prerequisite: Node.js `>=18`.
   - paper mode is default; live mode requires explicit caps (`--max-amount-usdc`, `--max-open-exposure-usdc`, `--max-trades-per-day`).
 - `mirror plan`:
   - envelope is `ok=true`, `command="mirror.plan"`, with `data.sourceMarket`, `data.match`, `data.sizingInputs`, `data.liquidityRecommendation`, and `data.distributionHint`.
+- `mirror browse`:
+  - envelope is `ok=true`, `command="mirror.browse"`, with `data.filters`, `data.count`, and `data.items[]`.
 - `mirror deploy`:
-  - envelope is `ok=true`, `command="mirror.deploy"`, with `data.planDigest`, `data.deploymentArgs`, `data.tx`, `data.pandora`, and `data.postDeployChecks`.
+  - envelope is `ok=true`, `command="mirror.deploy"`, with `data.planDigest`, `data.deploymentArgs`, `data.tx`, `data.preflight`, `data.pandora`, `data.postDeployChecks`, and optional `data.trustManifest`.
 - `mirror verify`:
-  - envelope is `ok=true`, `command="mirror.verify"`, with `data.matchConfidence`, `data.ruleHashLeft`, `data.ruleHashRight`, `data.ruleDiffSummary`, `data.similarityChecks[]`, and `data.gateResult`.
+  - envelope is `ok=true`, `command="mirror.verify"`, with `data.matchConfidence`, `data.ruleHashLeft`, `data.ruleHashRight`, `data.ruleDiffSummary`, `data.expiry`, optional `data.trustManifest`, `data.similarityChecks[]`, and `data.gateResult`.
+- `mirror go`:
+  - envelope is `ok=true`, `command="mirror.go"`, with staged results for `data.plan`, `data.deploy`, `data.verify`, optional `data.sync`, and `data.suggestedSyncCommand`.
 - `mirror sync`:
   - envelope is `ok=true`, `command="mirror.sync"`, with `data.strategyHash`, `data.stateFile`, `data.parameters`, `data.snapshots[]`, and `data.actions[]`.
   - hedge controls: `--hedge-trigger-usdc`, `--max-hedge-usdc`, `--hedge-ratio <n>` (default `1`), and `--no-hedge` to disable hedge execution while keeping drift rebalancing active.
+  - trust controls: `--trust-deploy [--manifest-file <path>]`.
+  - streaming: `--stream` emits per-tick logs for `mirror sync run` (table mode streams by default).
   - rebalance sizing is pool-aware: drift notional scales with `reserveYes + reserveNo`, then bounded by `--max-rebalance-usdc`.
   - Polymarket resilience: when Polymarket endpoints are unreachable, cached snapshots under `~/.pandora/polymarket` are reused for read paths; live sync blocks execution if source data is cached/stale.
 - `mirror status`:
-  - envelope is `ok=true`, `command="mirror.status"`, with `data.stateFile`, `data.strategyHash`, and persisted `data.state`.
+  - envelope is `ok=true`, `command="mirror.status"`, with `data.stateFile`, `data.strategyHash`, persisted `data.state`, and optional `data.live` when `--with-live` is used.
+- `mirror close`:
+  - envelope is `ok=true`, `command="mirror.close"`, with `data.mode` and unwind `data.steps[]` scaffold.
 - `webhook test`:
   - envelope is `ok=true`, `command="webhook.test"`, with per-target delivery and retry metadata.
 - `leaderboard`:

package/SKILL.md

@@ -45,7 +45,7 @@ npm link
   - `pandora export`
   - `pandora arbitrage`
   - `pandora autopilot run|once`
-  - `pandora mirror plan|deploy|verify|sync|status`
+  - `pandora mirror browse|plan|deploy|verify|go|sync|status|close`
   - `pandora webhook test`
   - `pandora leaderboard`
   - `pandora analyze`
@@ -98,10 +98,13 @@ pandora --output json history --wallet <0x...> --limit 50
 pandora --output json export --wallet <0x...> --format csv --out ./trades.csv
 pandora --output json arbitrage --venues pandora,polymarket --min-spread-pct 3 --cross-venue-only --with-rules --include-similarity
 pandora --output json autopilot once --market-address <0x...> --side no --amount-usdc 10 --trigger-yes-below 15 --paper
+pandora --output json mirror browse --min-yes-pct 20 --max-yes-pct 80 --min-volume-24h 100000 --limit 10
 pandora --output json mirror plan --source polymarket --polymarket-market-id <id> --with-rules --include-similarity
+pandora --output json mirror go --polymarket-slug <slug> --liquidity-usdc 10 --paper
 pandora --output json mirror verify --pandora-market-address <0x...> --polymarket-market-id <id> --include-similarity
 pandora --output json mirror sync once --pandora-market-address <0x...> --polymarket-market-id <id> --paper --hedge-ratio 1.0
-pandora --output json mirror status --strategy-hash <hash>
+pandora --output json mirror status --strategy-hash <hash> --with-live
+pandora --output json mirror close --pandora-market-address <0x...> --polymarket-market-id <id> --dry-run
 pandora --output json webhook test --webhook-url https://example.com/hook
 pandora --output json leaderboard --metric profit --limit 20
 pandora --output json analyze --market-address <0x...> --provider mock
@@ -162,13 +165,16 @@ pandora --output json suggest --wallet <0x...> --risk medium --budget 50 --inclu
   - `--include-similarity` includes pairwise similarity diagnostics for agent verification.
 - `autopilot`: paper-first trigger loop with persisted local state and idempotency.
 - `mirror plan`: Polymarket mirror sizing plan with liquidity recommendation and distribution hint.
-- `mirror deploy`: dry-run/execute Pandora AMM deployment from mirror plan inputs.
-- `mirror verify`: explicit question/rules similarity endpoint for AI-subagent validation.
+- `mirror browse`: Polymarket candidate discovery with optional Pandora mirror hints.
+- `mirror deploy`: dry-run/execute Pandora AMM deployment from mirror plan inputs, with execute-time wallet preflight and trust-manifest persistence.
+- `mirror verify`: explicit question/rules similarity endpoint for AI-subagent validation, with optional `--trust-deploy` manifest bypass for similarity.
+- `mirror go`: one-command orchestration for plan → deploy → verify, with optional auto-sync start.
 - `mirror sync`: paper-first delta-neutral loop with strict gates, state persistence, and optional live hedging (`--hedge-ratio <n>`, `--no-hedge`).
   - live hedge env: `POLYMARKET_PRIVATE_KEY`, `POLYMARKET_FUNDER`, `POLYMARKET_API_KEY`, `POLYMARKET_API_SECRET`, `POLYMARKET_API_PASSPHRASE`, `POLYMARKET_HOST`.
   - rebalance sizing is pool-aware and bounded by `--max-rebalance-usdc`.
   - endpoint resilience: Polymarket snapshots are cached under `~/.pandora/polymarket`; paper/read flows can reuse cache during outages, while live sync blocks cached sources.
-- `mirror status`: local mirror state inspection (no network side effects).
+- `mirror status`: local mirror state inspection with optional live market diagnostics (`--with-live`).
+- `mirror close`: deterministic unwind scaffold for LP withdrawal + hedge unwind flow.
 - `webhook test`: channel validation for generic, Telegram, and Discord payload delivery.
 - `leaderboard`: ranked user aggregates by profit/volume/win-rate.
   - invalid indexer aggregates are sanitized (win-rate capped to 0-100%) and emitted in diagnostics.

package/cli/lib/mirror_close_service.cjs

@@ -0,0 +1,42 @@
+const MIRROR_CLOSE_SCHEMA_VERSION = '1.0.0';
+
+function buildMirrorClosePlan(options = {}) {
+  const mode = options.execute ? 'execute' : 'dry-run';
+  const steps = [
+    {
+      key: 'pandora-withdraw-lp',
+      description: 'Withdraw LP position from Pandora AMM.',
+      status: mode === 'execute' ? 'pending' : 'planned',
+    },
+    {
+      key: 'polymarket-unwind-hedge',
+      description: 'Close hedge position on Polymarket.',
+      status: mode === 'execute' ? 'pending' : 'planned',
+    },
+    {
+      key: 'finalize-report',
+      description: 'Compute final mirror unwind report and PnL approximation.',
+      status: mode === 'execute' ? 'pending' : 'planned',
+    },
+  ];
+
+  return {
+    schemaVersion: MIRROR_CLOSE_SCHEMA_VERSION,
+    generatedAt: new Date().toISOString(),
+    mode,
+    pandoraMarketAddress: options.pandoraMarketAddress || null,
+    polymarketMarketId: options.polymarketMarketId || null,
+    polymarketSlug: options.polymarketSlug || null,
+    steps,
+    diagnostics: [
+      mode === 'execute'
+        ? 'Execution path is scaffolded and currently gated.'
+        : 'Dry-run close plan generated.',
+    ],
+  };
+}
+
+module.exports = {
+  MIRROR_CLOSE_SCHEMA_VERSION,
+  buildMirrorClosePlan,
+};

package/cli/lib/mirror_manifest_store.cjs

@@ -0,0 +1,148 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+
+const MIRROR_MANIFEST_SCHEMA_VERSION = '1.0.0';
+
+function expandHome(filePath) {
+  if (!filePath) return filePath;
+  if (filePath === '~') return os.homedir();
+  if (filePath.startsWith('~/')) return path.join(os.homedir(), filePath.slice(2));
+  return filePath;
+}
+
+function defaultManifestFile() {
+  return path.join(os.homedir(), '.pandora', 'mirror', 'pairs.json');
+}
+
+function resolveManifestPath(filePath) {
+  return path.resolve(expandHome(filePath || defaultManifestFile()));
+}
+
+function ensureManifestShape(raw) {
+  const data = raw && typeof raw === 'object' ? raw : {};
+  const pairs = Array.isArray(data.pairs) ? data.pairs : [];
+  return {
+    schemaVersion: MIRROR_MANIFEST_SCHEMA_VERSION,
+    generatedAt: data.generatedAt || new Date().toISOString(),
+    pairs,
+  };
+}
+
+function readManifest(filePath) {
+  const resolved = resolveManifestPath(filePath);
+  if (!fs.existsSync(resolved)) {
+    return {
+      filePath: resolved,
+      manifest: ensureManifestShape({}),
+    };
+  }
+
+  let parsed = {};
+  try {
+    parsed = JSON.parse(fs.readFileSync(resolved, 'utf8'));
+  } catch {
+    parsed = {};
+  }
+
+  return {
+    filePath: resolved,
+    manifest: ensureManifestShape(parsed),
+  };
+}
+
+function saveManifest(filePath, manifest) {
+  const resolved = resolveManifestPath(filePath);
+  fs.mkdirSync(path.dirname(resolved), { recursive: true });
+  const tmpPath = `${resolved}.${process.pid}.${Date.now()}.${crypto.randomBytes(4).toString('hex')}.tmp`;
+  fs.writeFileSync(tmpPath, JSON.stringify(manifest, null, 2));
+  fs.renameSync(tmpPath, resolved);
+  return resolved;
+}
+
+function pairMatches(record, selector = {}) {
+  const leftMarket = String(record && record.pandoraMarketAddress ? record.pandoraMarketAddress : '').toLowerCase();
+  const rightMarket = String(selector && selector.pandoraMarketAddress ? selector.pandoraMarketAddress : '').toLowerCase();
+  if (leftMarket && rightMarket && leftMarket !== rightMarket) return false;
+
+  const leftCondition = String(record && record.polymarketMarketId ? record.polymarketMarketId : '').toLowerCase();
+  const rightCondition = String(selector && selector.polymarketMarketId ? selector.polymarketMarketId : '').toLowerCase();
+  if (leftCondition && rightCondition && leftCondition !== rightCondition) return false;
+
+  const leftSlug = String(record && record.polymarketSlug ? record.polymarketSlug : '').toLowerCase();
+  const rightSlug = String(selector && selector.polymarketSlug ? selector.polymarketSlug : '').toLowerCase();
+  if (leftSlug && rightSlug && leftSlug !== rightSlug) return false;
+
+  if (!rightMarket && !rightCondition && !rightSlug) return false;
+  return true;
+}
+
+function findPair(filePath, selector = {}) {
+  const loaded = readManifest(filePath);
+  const pairs = Array.isArray(loaded.manifest.pairs) ? loaded.manifest.pairs : [];
+  const match = pairs.find((record) => pairMatches(record, selector)) || null;
+  return {
+    filePath: loaded.filePath,
+    manifest: loaded.manifest,
+    pair: match,
+  };
+}
+
+function buildPairId(record) {
+  const hash = crypto.createHash('sha256');
+  hash.update(
+    JSON.stringify({
+      pandoraMarketAddress: String(record.pandoraMarketAddress || '').toLowerCase(),
+      polymarketMarketId: String(record.polymarketMarketId || '').toLowerCase(),
+      polymarketSlug: String(record.polymarketSlug || '').toLowerCase(),
+    }),
+  );
+  return hash.digest('hex').slice(0, 16);
+}
+
+function upsertPair(filePath, record = {}) {
+  const loaded = readManifest(filePath);
+  const manifest = loaded.manifest;
+  const nowIso = new Date().toISOString();
+  const pair = {
+    id: record.id || buildPairId(record),
+    createdAt: record.createdAt || nowIso,
+    updatedAt: nowIso,
+    trusted: record.trusted !== false,
+    pandoraMarketAddress: record.pandoraMarketAddress || null,
+    pandoraPollAddress: record.pandoraPollAddress || null,
+    polymarketMarketId: record.polymarketMarketId || null,
+    polymarketSlug: record.polymarketSlug || null,
+    sourceQuestion: record.sourceQuestion || null,
+    sourceRuleHash: record.sourceRuleHash || null,
+  };
+
+  const items = Array.isArray(manifest.pairs) ? manifest.pairs.slice() : [];
+  const index = items.findIndex((item) => pairMatches(item, pair));
+  if (index >= 0) {
+    pair.createdAt = items[index].createdAt || pair.createdAt;
+    items[index] = { ...items[index], ...pair };
+  } else {
+    items.push(pair);
+  }
+
+  manifest.pairs = items;
+  manifest.generatedAt = nowIso;
+  const savedPath = saveManifest(loaded.filePath, manifest);
+  return {
+    filePath: savedPath,
+    pair,
+    manifest,
+  };
+}
+
+module.exports = {
+  MIRROR_MANIFEST_SCHEMA_VERSION,
+  defaultManifestFile,
+  resolveManifestPath,
+  readManifest,
+  saveManifest,
+  findPair,
+  upsertPair,
+};

package/cli/lib/mirror_service.cjs

@@ -2,12 +2,14 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const { computeLiquidityRecommendation, computeDistributionHint, normalizeProbability } = require('./mirror_sizing_service.cjs');
-const { resolvePolymarketMarket, fetchDepthForMarket } = require('./polymarket_trade_adapter.cjs');
-const { findBestPandoraMatch, fetchPandoraMarketContext, verifyMirrorPair } = require('./mirror_verify_service.cjs');
+const { resolvePolymarketMarket, fetchDepthForMarket, browsePolymarketMarkets } = require('./polymarket_trade_adapter.cjs');
+const { findBestPandoraMatch, fetchPandoraMarketContext, verifyMirrorPair, hashRules } = require('./mirror_verify_service.cjs');
 const { deployPandoraAmmMarket } = require('./pandora_deploy_service.cjs');
+const { defaultManifestFile, upsertPair } = require('./mirror_manifest_store.cjs');
 
 const MIRROR_PLAN_SCHEMA_VERSION = '1.0.0';
 const MIRROR_DEPLOY_SCHEMA_VERSION = '1.0.0';
+const MIRROR_BROWSE_SCHEMA_VERSION = '1.0.0';
 
 function round(value, decimals = 6) {
   const numeric = Number(value);
@@ -20,6 +22,15 @@ function clamp(value, min, max) {
   return Math.max(min, Math.min(max, value));
 }
 
+function createServiceError(code, message, details = undefined) {
+  const err = new Error(message);
+  err.code = code;
+  if (details !== undefined) {
+    err.details = details;
+  }
+  return err;
+}
+
 function normalizeSources(value) {
   if (!value) return [];
   if (Array.isArray(value)) {
@@ -68,6 +79,8 @@ async function buildMirrorPlan(options = {}) {
 
   const sourceMarket = await resolvePolymarketMarket({
     host: options.polymarketHost,
+    gammaUrl: options.polymarketGammaUrl,
+    gammaMockUrl: options.polymarketGammaMockUrl,
     mockUrl: options.polymarketMockUrl,
     timeoutMs: options.timeoutMs,
     marketId: options.polymarketMarketId,
@@ -110,6 +123,14 @@ async function buildMirrorPlan(options = {}) {
     limit: 150,
   });
 
+  if (Number.isFinite(sourceMarket.closeTimestamp)) {
+    const nowSec = Math.floor(Date.now() / 1000);
+    const timeToCloseSec = sourceMarket.closeTimestamp - nowSec;
+    if (timeToCloseSec <= 24 * 60 * 60) {
+      diagnostics.push(`Source market closes soon (${timeToCloseSec}s). Consider higher monitoring cadence.`);
+    }
+  }
+
   for (const item of sourceMarket.diagnostics || []) diagnostics.push(item);
   for (const item of depth.diagnostics || []) diagnostics.push(item);
   for (const item of sizing.diagnostics || []) diagnostics.push(item);
@@ -214,7 +235,7 @@ function resolveDeployPlanInput(options = {}) {
 }
 
 async function deployMirror(options = {}) {
-  let planData = resolveDeployPlanInput(options);
+  let planData = options.planData || resolveDeployPlanInput(options);
   if (!planData) {
     planData = await buildMirrorPlan(options);
   }
@@ -249,26 +270,63 @@ async function deployMirror(options = {}) {
     diagnostics.push('Using fallback source URLs because explicit --sources were not provided.');
   }
 
-  const deployPayload = await deployPandoraAmmMarket({
-    execute: Boolean(options.execute),
-    chainId: options.chainId,
-    rpcUrl: options.rpcUrl,
-    privateKey: options.privateKey,
-    oracle: options.oracle,
-    factory: options.factory,
-    usdc: options.usdc,
-    question,
-    rules: sourceRulesText,
-    sources: sources.length >= 2 ? sources : ['https://polymarket.com', 'https://clob.polymarket.com'],
-    targetTimestamp,
-    liquidityUsdc,
-    distributionYes,
-    distributionNo,
-    feeTier: options.feeTier || 3000,
-    maxImbalance: options.maxImbalance || 10_000,
-    arbiter: options.arbiter,
-    category: options.category,
-  });
+  let deployPayload;
+  try {
+    deployPayload = await deployPandoraAmmMarket({
+      execute: Boolean(options.execute),
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl,
+      privateKey: options.privateKey,
+      oracle: options.oracle,
+      factory: options.factory,
+      usdc: options.usdc,
+      question,
+      rules: sourceRulesText,
+      sources: sources.length >= 2 ? sources : ['https://polymarket.com', 'https://clob.polymarket.com'],
+      targetTimestamp,
+      minCloseLeadSeconds: Number.isFinite(Number(options.minCloseLeadSeconds))
+        ? Number(options.minCloseLeadSeconds)
+        : 3600,
+      liquidityUsdc,
+      distributionYes,
+      distributionNo,
+      feeTier: options.feeTier || 3000,
+      maxImbalance: options.maxImbalance || 10_000,
+      arbiter: options.arbiter,
+      category: options.category,
+    });
+  } catch (err) {
+    throw createServiceError(
+      err && err.code ? err.code : 'MIRROR_DEPLOY_FAILED',
+      err && err.message ? err.message : String(err),
+      err && err.details ? err.details : undefined,
+    );
+  }
+
+  let trustManifest = null;
+  if (options.execute && deployPayload.pandora && deployPayload.pandora.marketAddress) {
+    const manifestFile = options.manifestFile || defaultManifestFile();
+    try {
+      const manifestUpdate = upsertPair(manifestFile, {
+        trusted: true,
+        pandoraMarketAddress: deployPayload.pandora.marketAddress,
+        pandoraPollAddress: deployPayload.pandora.pollAddress,
+        polymarketMarketId: planData.sourceMarket && planData.sourceMarket.marketId ? String(planData.sourceMarket.marketId) : options.polymarketMarketId || null,
+        polymarketSlug: planData.sourceMarket && planData.sourceMarket.slug ? String(planData.sourceMarket.slug) : options.polymarketSlug || null,
+        sourceQuestion: planData.sourceMarket && planData.sourceMarket.question ? planData.sourceMarket.question : null,
+        sourceRuleHash: hashRules(sourceRulesText),
+      });
+      trustManifest = {
+        filePath: manifestUpdate.filePath,
+        pair: manifestUpdate.pair,
+      };
+    } catch (err) {
+      throw createServiceError(
+        'MIRROR_MANIFEST_WRITE_FAILED',
+        `Failed to persist mirror trust manifest: ${err && err.message ? err.message : String(err)}`,
+      );
+    }
+  }
 
   const postDeployChecks = {
     seedOddsMatch: null,
@@ -318,6 +376,7 @@ async function deployMirror(options = {}) {
     tx: deployPayload.tx,
     pandora: deployPayload.pandora,
     postDeployChecks,
+    trustManifest,
     diagnostics: diagnostics.concat(deployPayload.diagnostics || []),
   };
 }
@@ -326,11 +385,66 @@ async function verifyMirror(options = {}) {
   return verifyMirrorPair(options);
 }
 
+async function browseMirrorMarkets(options = {}) {
+  const diagnostics = [];
+  const polymarket = await browsePolymarketMarkets({
+    gammaUrl: options.polymarketGammaUrl,
+    gammaMockUrl: options.polymarketGammaMockUrl,
+    mockUrl: options.polymarketMockUrl,
+    timeoutMs: options.timeoutMs,
+    minYesPct: options.minYesPct,
+    maxYesPct: options.maxYesPct,
+    minVolume24h: options.minVolume24h,
+    closesAfter: options.closesAfter,
+    closesBefore: options.closesBefore,
+    questionContains: options.questionContains,
+    limit: options.limit,
+  });
+
+  const items = [];
+  for (const entry of polymarket.items || []) {
+    let existingMirror = null;
+    if (options.indexerUrl) {
+      const match = await findBestPandoraMatch({
+        indexerUrl: options.indexerUrl,
+        timeoutMs: options.timeoutMs,
+        chainId: options.chainId,
+        sourceQuestion: entry.question,
+        limit: 100,
+      });
+      if (match.best && match.best.similarity && Number(match.best.similarity.score) >= 0.86) {
+        existingMirror = {
+          marketAddress: match.best.marketAddress,
+          similarity: match.best.similarity.score,
+        };
+      }
+      diagnostics.push(...(match.diagnostics || []));
+    }
+
+    items.push({
+      ...entry,
+      existingMirror,
+    });
+  }
+
+  return {
+    schemaVersion: MIRROR_BROWSE_SCHEMA_VERSION,
+    generatedAt: new Date().toISOString(),
+    source: polymarket.source,
+    filters: polymarket.filters,
+    count: items.length,
+    items,
+    diagnostics: (polymarket.diagnostics || []).concat(diagnostics),
+  };
+}
+
 module.exports = {
   MIRROR_PLAN_SCHEMA_VERSION,
   MIRROR_DEPLOY_SCHEMA_VERSION,
+  MIRROR_BROWSE_SCHEMA_VERSION,
   buildMirrorPlan,
   deployMirror,
   verifyMirror,
+  browseMirrorMarkets,
   buildPlanDigest,
 };

package/cli/lib/mirror_state_store.cjs

@@ -34,11 +34,23 @@ function ensureStateShape(raw, hash) {
     schemaVersion: MIRROR_STATE_SCHEMA_VERSION,
     strategyHash: resolvedHash,
     startedAt: data.startedAt || new Date().toISOString(),
+    pandoraMarketAddress: data.pandoraMarketAddress || null,
+    polymarketMarketId: data.polymarketMarketId || null,
+    polymarketSlug: data.polymarketSlug || null,
     lastTickAt: data.lastTickAt || null,
     lastResetDay: data.lastResetDay || new Date().toISOString().slice(0, 10),
     tradesToday: Number.isFinite(Number(data.tradesToday)) ? Number(data.tradesToday) : 0,
     dailySpendUsdc: Number.isFinite(Number(data.dailySpendUsdc)) ? Number(data.dailySpendUsdc) : 0,
     currentHedgeUsdc: Number.isFinite(Number(data.currentHedgeUsdc)) ? Number(data.currentHedgeUsdc) : 0,
+    cumulativeLpFeesApproxUsdc: Number.isFinite(Number(data.cumulativeLpFeesApproxUsdc))
+      ? Number(data.cumulativeLpFeesApproxUsdc)
+      : 0,
+    cumulativeHedgeNotionalUsdc: Number.isFinite(Number(data.cumulativeHedgeNotionalUsdc))
+      ? Number(data.cumulativeHedgeNotionalUsdc)
+      : 0,
+    cumulativeHedgeCostApproxUsdc: Number.isFinite(Number(data.cumulativeHedgeCostApproxUsdc))
+      ? Number(data.cumulativeHedgeCostApproxUsdc)
+      : 0,
     lastExecution: data.lastExecution || null,
     idempotencyKeys: Array.isArray(data.idempotencyKeys) ? data.idempotencyKeys : [],
     alerts: Array.isArray(data.alerts) ? data.alerts : [],
@@ -71,8 +83,25 @@ function saveState(filePath, state) {
   const resolved = path.resolve(expandHome(filePath));
   fs.mkdirSync(path.dirname(resolved), { recursive: true });
   const tmpPath = `${resolved}.${process.pid}.${Date.now()}.${crypto.randomBytes(4).toString('hex')}.tmp`;
-  fs.writeFileSync(tmpPath, JSON.stringify(state, null, 2));
-  fs.renameSync(tmpPath, resolved);
+  const serialized = JSON.stringify(state, null, 2);
+  fs.writeFileSync(tmpPath, serialized);
+  try {
+    fs.renameSync(tmpPath, resolved);
+  } catch (err) {
+    if (err && err.code === 'ENOENT') {
+      fs.mkdirSync(path.dirname(resolved), { recursive: true });
+      fs.writeFileSync(resolved, serialized);
+      if (fs.existsSync(tmpPath)) {
+        try {
+          fs.unlinkSync(tmpPath);
+        } catch {
+          // ignore cleanup failure
+        }
+      }
+    } else {
+      throw err;
+    }
+  }
   return resolved;
 }