@reshotdev/screenshot 0.0.1-beta.2 → 0.0.1-beta.21

package/src/commands/publish.js

@@ -15,6 +15,10 @@ const {
   getStorageMode,
   isPlatformAvailable,
 } = require("../lib/storage-providers");
+const {
+  getLatestSuccessfulRunManifest,
+  getLatestUsableRunManifest,
+} = require("../lib/run-manifest");
 const pkg = require("../../package.json");
 
 // Check if transactional flow should be used (R2 configured on server)
@@ -52,20 +56,44 @@ function loadDiffManifests(outputBaseDir) {
       const latestVersion = versions.sort().reverse()[0];
       if (!latestVersion) continue;
 
-      const manifestPath = path.join(
-        scenarioDir,
-        latestVersion,
-        "diff-manifest.json",
-      );
+      const versionDir = path.join(scenarioDir, latestVersion);
+
+      // `run` writes diff-manifest.json into the ACTUAL output dir, which
+      // includes the variant subdir (e.g. <version>/default/diff-manifest.json),
+      // not the version dir itself. Read the version-level manifest if present
+      // AND every variant subdir's manifest, merging their `assets` so the diff
+      // the CLI computed actually reaches publish (otherwise the platform stores
+      // diffPercentage: null and Activity shows "0 changed" — audit run-13 H1).
+      const candidatePaths = [path.join(versionDir, "diff-manifest.json")];
+      try {
+        for (const entry of fs.readdirSync(versionDir)) {
+          const entryPath = path.join(versionDir, entry);
+          if (fs.statSync(entryPath).isDirectory()) {
+            candidatePaths.push(path.join(entryPath, "diff-manifest.json"));
+          }
+        }
+      } catch (e) {
+        // version dir unreadable — fall back to the version-level path only
+      }
 
-      if (fs.existsSync(manifestPath)) {
+      const merged = { assets: {} };
+      let foundAny = false;
+      for (const manifestPath of candidatePaths) {
+        if (!fs.existsSync(manifestPath)) continue;
         try {
           const manifest = fs.readJSONSync(manifestPath);
-          manifests.set(`${scenarioKey}/${latestVersion}`, manifest);
+          foundAny = true;
+          Object.assign(merged, manifest, {
+            assets: { ...merged.assets, ...(manifest.assets || {}) },
+          });
         } catch (e) {
           // Skip malformed manifests
         }
       }
+
+      if (foundAny) {
+        manifests.set(`${scenarioKey}/${latestVersion}`, merged);
+      }
     }
   } catch (e) {
     // Return empty if directory structure is unexpected
@@ -390,13 +418,13 @@ function resolveProjectContext({ settings, docSyncConfig, storageMode }) {
   if (!apiKey) {
     throw new Error(
       "No API key found. Set RESHOT_API_KEY in your environment or run `reshot auth` locally to create .reshot/settings.json.\n" +
-        "Alternatively, configure BYOS (Bring Your Own Storage) in docsync.config.json to publish without authentication.",
+        "Alternatively, configure BYOS (Bring Your Own Storage) in reshot.config.json to publish without authentication.",
     );
   }
 
   if (!projectId) {
     throw new Error(
-      "No project ID found. Set RESHOT_PROJECT_ID in your environment or ensure docsync.config.json contains _metadata.projectId.",
+      "No project ID found. Set RESHOT_PROJECT_ID in your environment or ensure reshot.config.json contains _metadata.projectId.",
     );
   }
 
@@ -487,6 +515,48 @@ function groupAssetsByScenario(assetFiles, outputBaseDir) {
   return Array.from(groups.values());
 }
 
+function collectAssetFilesFromDirectories(directories) {
+  const deduped = new Set();
+  const files = [];
+
+  for (const directory of directories) {
+    if (!directory || !fs.existsSync(directory)) continue;
+    for (const filePath of findAssetFiles(directory)) {
+      if (deduped.has(filePath)) continue;
+      deduped.add(filePath);
+      files.push(filePath);
+    }
+  }
+
+  return files;
+}
+
+function resolveManifestScopedScreenshotFiles(outputBaseDir, latestRunManifest) {
+  if (!latestRunManifest) {
+    throw new Error(
+      "No run manifest is available. Run `reshot run` first or use `reshot publish --all-output` to publish from the full output tree.",
+    );
+  }
+
+  const scenarioDirs = (latestRunManifest.scenarios || [])
+    .filter((scenario) => scenario.success !== false)
+    .map((scenario) => scenario.outputDir)
+    .filter(Boolean);
+
+  if (scenarioDirs.length === 0) {
+    throw new Error(
+      "The run manifest does not contain any successful scenario output directories.",
+    );
+  }
+
+  const screenshotFiles = collectAssetFilesFromDirectories(scenarioDirs);
+  return {
+    screenshotFiles,
+    mode: "latest-run",
+    scenarioCount: scenarioDirs.length,
+  };
+}
+
 function buildContextForVariation(scenario, variationSlug) {
   const safeVariation = variationSlug || "default";
   if (!scenario || !scenario.contexts) {
@@ -539,17 +609,25 @@ function buildScenarioDefinition(scenario) {
 function buildPublishMetadata({
   projectId,
   publishSessionId,
+  tag,
   scenarioKey,
   scenarioConfig,
   variationSlug,
   contextData,
   gitInfo,
+  autoApprove = false,
 }) {
   const scenarioDefinition = buildScenarioDefinition(scenarioConfig);
 
+  // Only attach git metadata when a real commit hash is available. Sending
+  // empty git values when the repo has no HEAD causes the platform to reject
+  // the batch with an opaque 400.
+  const hasGit = !!(gitInfo && gitInfo.commitHash);
+
   return {
     projectId,
     publishSessionId, // Unique ID for this CLI publish run
+    tag: tag || undefined,
     scenarioName: scenarioConfig?.name || scenarioKey,
     scenario: scenarioDefinition,
     context: {
@@ -557,10 +635,17 @@ function buildPublishMetadata({
       data: contextData,
     },
     autoCreateVisuals: true,
-    git: {
-      commitHash: gitInfo.commitHash,
-      commitMessage: gitInfo.commitMessage,
+    publish: {
+      autoApprove,
     },
+    ...(hasGit
+      ? {
+          git: {
+            commitHash: gitInfo.commitHash,
+            commitMessage: gitInfo.commitMessage,
+          },
+        }
+      : {}),
     cli: {
       version: pkg.version,
       captureTimestamp: new Date().toISOString(),
@@ -568,6 +653,24 @@ function buildPublishMetadata({
   };
 }
 
+/**
+ * Read pixel dimensions from a captured image so the platform can store and
+ * expose them (used by `reshot pull` for CLS-safe `<img width height>`
+ * embedding). Returns nulls for non-images or on any error — never throws.
+ */
+async function getImageDimensions(filePath, contentType) {
+  if (!filePath || !(contentType || "").startsWith("image/")) {
+    return { width: null, height: null };
+  }
+  try {
+    const sharp = require("sharp");
+    const meta = await sharp(filePath).metadata();
+    return { width: meta.width ?? null, height: meta.height ?? null };
+  } catch {
+    return { width: null, height: null };
+  }
+}
+
 /**
  * Publish using transactional flow (direct R2 upload with presigned URLs)
  */
@@ -578,6 +681,7 @@ async function publishWithTransactionalFlow(
   docSyncConfig,
   gitInfo,
   diffManifests = null,
+  { autoApprove = false } = {},
 ) {
   console.log(
     chalk.cyan("  🚀 Using transactional upload (direct to R2)...\n"),
@@ -586,6 +690,7 @@ async function publishWithTransactionalFlow(
   let successCount = 0;
   let failCount = 0;
   let skippedCount = 0;
+  let reviewPendingCount = 0;
   let viewUrl = null;
 
   // Flatten all assets with metadata
@@ -627,6 +732,52 @@ async function publishWithTransactionalFlow(
     }
   }
 
+  // ── DOM scene sidecars (MHTML bundles next to each PNG) ─────────────
+  // The CLI emits an .mhtml alongside each PNG when scenario.domScene !==
+  // false. We upload them as sidecar assets linked to the parent PNG's
+  // visual version via _parentVisualKey, so the server can persist the
+  // sidecar's s3Path on the same VisualVersion row.
+  const domSceneSidecars = [];
+  for (const f of allFiles) {
+    // Only attach MHTML to PNG screenshots (not videos, not other sidecars).
+    if (path.extname(f.path).toLowerCase() !== ".png") continue;
+    if (f._isThumbnail || f._isDomScene) continue;
+
+    const candidate =
+      (f.asset && f.asset.domScenePath) ||
+      f.path.replace(/\.png$/i, ".mhtml");
+    if (!fs.existsSync(candidate)) continue;
+
+    const sidecarStat = fs.statSync(candidate);
+    domSceneSidecars.push({
+      group: f.group,
+      asset: {
+        captureKey: f.asset.captureKey,
+        path: candidate,
+        filename: path.basename(candidate),
+      },
+      scenarioConfig: f.scenarioConfig,
+      key: f.key,
+      visualKey: f.visualKey,
+      path: candidate,
+      size: sidecarStat.size,
+      contentType: "multipart/related",
+      hash: null,
+      diffData: null,
+      thumbnailPath: null,
+      _isDomScene: true,
+      _parentVisualKey: f.visualKey,
+    });
+  }
+  if (domSceneSidecars.length > 0) {
+    console.log(
+      chalk.gray(
+        `  Attaching ${domSceneSidecars.length} DOM scene sidecar(s)...`,
+      ),
+    );
+    allFiles.push(...domSceneSidecars);
+  }
+
   // Generate thumbnails for video files (first frame as PNG)
   const videoExts = new Set([".mp4", ".webm", ".mov"]);
   const videoFiles = allFiles.filter((f) =>
@@ -726,7 +877,10 @@ async function publishWithTransactionalFlow(
 
   // Step 3: Upload files directly to R2 (parallel with concurrency limit)
   console.log(chalk.gray("  Uploading files directly to R2..."));
-  const CONCURRENCY = 5;
+  const CONCURRENCY = Math.min(
+    Math.max(parseInt(process.env.RESHOT_UPLOAD_CONCURRENCY || "10", 10), 1),
+    20,
+  );
   const uploadQueue = [...allFiles];
   const uploadResults = [];
 
@@ -749,7 +903,16 @@ async function publishWithTransactionalFlow(
           contentType: file.contentType,
         });
 
-        console.log(chalk.green(`     ✔ Uploaded ${file.visualKey}`));
+        // Label the artifact type so PNG + MHTML-sidecar lines for the same
+        // visual don't read as a duplicate-upload bug (audit run-10 F3).
+        const artifactLabel = file._isThumbnail
+          ? "thumbnail"
+          : file._isDomScene
+            ? "dom scene .mhtml"
+            : (path.extname(file.path || "").replace(/^\./, "") || "asset");
+        console.log(
+          chalk.green(`     ✔ Uploaded ${file.visualKey} (${artifactLabel})`),
+        );
         return { success: true, file, s3Path: urlInfo.path };
       } catch (err) {
         console.log(
@@ -768,21 +931,33 @@ async function publishWithTransactionalFlow(
 
   // Build a map of thumbnail s3Paths keyed by parent visualKey
   const thumbnailS3Paths = new Map();
+  // Build a map of DOM-scene MHTML s3Paths keyed by parent visualKey.
+  // The server attaches these to the parent VisualVersion as a sidecar.
+  const domSceneS3Paths = new Map();
+  const domSceneSizes = new Map();
   for (const result of uploadResults) {
-    if (result.success && result.file._isThumbnail) {
+    if (!result.success) continue;
+    if (result.file._isThumbnail) {
       thumbnailS3Paths.set(result.file._parentVisualKey, result.s3Path);
+    } else if (result.file._isDomScene) {
+      domSceneS3Paths.set(result.file._parentVisualKey, result.s3Path);
+      domSceneSizes.set(result.file._parentVisualKey, result.file.size);
     }
   }
 
-  // Group successful uploads by scenario/variant (skip thumbnails — they're metadata)
+  // Group successful uploads by scenario/variant (skip thumbnails + DOM
+  // sidecars — they're metadata attached to their parent asset).
+  const failedUploadKeys = [];
   const groupMap = new Map();
   for (const result of uploadResults) {
     if (!result.success) {
-      if (!result.file._isThumbnail) failCount++;
+      if (!result.file._isThumbnail && !result.file._isDomScene) {
+        failCount++;
+        failedUploadKeys.push(result.file.visualKey);
+      }
       continue;
     }
-    // Thumbnails are attached to their parent asset, not committed separately
-    if (result.file._isThumbnail) continue;
+    if (result.file._isThumbnail || result.file._isDomScene) continue;
 
     const groupKey = `${result.file.group.scenarioKey}::${result.file.group.variationSlug}`;
     if (!groupMap.has(groupKey)) {
@@ -792,22 +967,36 @@ async function publishWithTransactionalFlow(
         assets: [],
       });
     }
+    const dimensions = await getImageDimensions(
+      result.file.path,
+      result.file.contentType,
+    );
     groupMap.get(groupKey).assets.push({
       key: result.file.key,
       s3Path: result.s3Path,
       hash: result.file.hash,
       visualKey: result.file.visualKey,
       size: result.file.size,
+      width: dimensions.width,
+      height: dimensions.height,
       contentType: result.file.contentType,
       // Include diff data from CLI analysis
       diffPercentage: result.file.diffData?.diffPercentage ?? null,
       diffStatus: result.file.diffData?.diffStatus ?? null,
       // Attach thumbnail for video assets
       thumbnailS3Path: thumbnailS3Paths.get(result.file.visualKey) ?? null,
+      // Attach DOM scene sidecar (MHTML) — the source of truth for
+      // marketing-team variations.
+      domSceneS3Path: domSceneS3Paths.get(result.file.visualKey) ?? null,
+      domSceneSize: domSceneSizes.get(result.file.visualKey) ?? null,
     });
   }
 
-  // Commit each group
+  // Build all commits for batch request
+  // Vercel serverless functions have ~60s timeout; keep batches small enough to complete
+  const MAX_BATCH_SIZE = 25;
+  const commits = [];
+
   for (const { group, scenarioConfig, assets } of groupMap.values()) {
     const contextObj = buildContextForVariation(
       scenarioConfig,
@@ -816,50 +1005,98 @@ async function publishWithTransactionalFlow(
     const metadata = buildPublishMetadata({
       projectId,
       publishSessionId: gitInfo.publishSessionId,
+      tag: gitInfo.tag,
       scenarioKey: group.scenarioKey,
       scenarioConfig,
       variationSlug: group.variationSlug,
       contextData: contextObj,
       gitInfo,
+      autoApprove,
     });
 
     if (metadata.cli) {
-      metadata.cli.features = ["steps", "transactional"];
+      metadata.cli.features = ["steps", "transactional", "batch"];
+    }
+
+    commits.push({ metadata, assets });
+  }
+
+  // Send in batches
+  console.log(
+    chalk.gray(`  Committing ${commits.length} scenario(s) to platform...`),
+  );
+
+  const totalBatches = Math.ceil(commits.length / MAX_BATCH_SIZE);
+  for (let i = 0; i < commits.length; i += MAX_BATCH_SIZE) {
+    const chunk = commits.slice(i, i + MAX_BATCH_SIZE);
+    const batchNum = Math.floor(i / MAX_BATCH_SIZE) + 1;
+    if (totalBatches > 1) {
+      console.log(chalk.gray(`  Batch ${batchNum}/${totalBatches}...`));
     }
 
     try {
-      const result = await apiClient.publishTransactional(apiKey, {
-        metadata,
-        assets,
+      const rawBatchResult = await apiClient.publishBatch(apiKey, {
+        commits: chunk,
+        autoApprove: autoApprove || false,
       });
+      // Unwrap API envelope: response may be { data: { results, ... } } or { results, ... }
+      const batchResult = rawBatchResult.data || rawBatchResult;
 
-      const processedCount = result?.assetsProcessed ?? assets.length;
-      console.log(
-        chalk.green(
-          `     ✔ Committed "${group.scenarioKey}" (${group.variationSlug}): ${processedCount} asset(s)`,
-        ),
-      );
-      successCount += processedCount;
+      // Count only NEWLY-pending (new/changed) captures, so the final summary
+      // doesn't imply a re-publish reset already-live captures (audit F1).
+      reviewPendingCount += batchResult.reviewQueueItems || 0;
+
+      for (const r of batchResult.results || []) {
+        if (r.status === "ok") {
+          const count = r.assetsProcessed || 0;
+          console.log(
+            chalk.green(
+              `     ✔ Committed "${r.scenario}" (${r.context}): ${count} asset(s)`,
+            ),
+          );
+          successCount += count;
 
-      // Handle skipped assets (visual limit)
-      if (result?.skippedAssets?.length > 0) {
-        for (const key of result.skippedAssets) {
-          console.log(chalk.yellow(`     ⚠ Skipped "${key}" (plan limit reached)`));
+          if (r.skippedAssets?.length > 0) {
+            for (const key of r.skippedAssets) {
+              console.log(chalk.yellow(`     ⚠ Skipped "${key}" (plan limit reached)`));
+            }
+            skippedCount += r.skippedAssets.length;
+          }
+        } else {
+          console.log(
+            chalk.red(
+              `     ✖ "${r.scenario}" (${r.context}): ${r.error || "Unknown error"}`,
+            ),
+          );
+          failCount++;
         }
-        skippedCount += result.skippedAssets.length;
       }
 
-      // Capture viewUrl from first successful response
-      if (!viewUrl && result?.viewUrl) {
-        viewUrl = result.viewUrl;
+      if (!viewUrl && batchResult.viewUrl) {
+        viewUrl = batchResult.viewUrl;
       }
     } catch (error) {
-      console.log(chalk.red(`     ✖ Commit failed: ${error.message}`));
-      failCount += assets.length;
+      // Surface the server's descriptive error body (e.g. a validation
+      // message) instead of just axios's opaque "Request failed with status
+      // code 400" — otherwise a 1-line fix turns into a support ticket.
+      const serverMsg =
+        error.response?.data?.error || error.response?.data?.message;
+      const detail = serverMsg
+        ? `${error.message} — ${serverMsg}`
+        : error.message;
+      console.log(chalk.red(`     ✖ Batch request failed: ${detail}`));
+      failCount += chunk.length;
     }
   }
 
-  return { successCount, failCount, skippedCount, viewUrl };
+  return {
+    successCount,
+    failCount,
+    skippedCount,
+    reviewPendingCount,
+    viewUrl,
+    failedUploadKeys,
+  };
 }
 
 /**
@@ -871,6 +1108,7 @@ async function publishWithLegacyFlow(
   groupedAssets,
   docSyncConfig,
   gitInfo,
+  { autoApprove = false } = {},
 ) {
   let successCount = 0;
   let failCount = 0;
@@ -887,11 +1125,13 @@ async function publishWithLegacyFlow(
     const metadata = buildPublishMetadata({
       projectId,
       publishSessionId: gitInfo.publishSessionId,
+      tag: gitInfo.tag,
       scenarioKey: group.scenarioKey,
       scenarioConfig,
       variationSlug: group.variationSlug,
       contextData: contextObj,
       gitInfo,
+      autoApprove,
     });
 
     if (metadata.cli) {
@@ -1131,14 +1371,28 @@ function getGitInfo() {
   try {
     const commitHash = execSync("git rev-parse HEAD", {
       encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
     }).trim();
     const commitMessage = execSync("git log -1 --pretty=%B", {
       encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
     }).trim();
-    return { commitHash, commitMessage };
+    return { commitHash, commitMessage, hasCommit: !!commitHash };
   } catch (error) {
-    console.warn(chalk.yellow("  ⚠ Could not read git information"));
-    return { commitHash: "", commitMessage: "" };
+    // No git HEAD — either not a git repo or a brand-new repo with no commits.
+    // Proceed WITHOUT git metadata rather than sending empty values that the
+    // platform rejects with an opaque 400 "Batch request failed".
+    console.log(
+      chalk.yellow(
+        "  ⚠ No git commit found — publishing without commit metadata.",
+      ),
+    );
+    console.log(
+      chalk.gray(
+        "    Tip: run `git commit` first to attach commit info to this publish.",
+      ),
+    );
+    return { commitHash: "", commitMessage: "", hasCommit: false };
   }
 }
 
@@ -1167,70 +1421,6 @@ function getRecentCommits(lastCommitHash) {
   }
 }
 
-/**
- * Recursively find all markdown files matching include/exclude patterns
- */
-function findDocFiles(
-  docsRoot,
-  includePatterns = ["**/*.md", "**/*.mdx"],
-  excludePatterns = [],
-) {
-  const files = [];
-  const rootPath = path.resolve(process.cwd(), docsRoot);
-
-  if (!fs.existsSync(rootPath)) {
-    return files;
-  }
-
-  function walkDir(dir, relativePath = "") {
-    const items = fs.readdirSync(dir);
-
-    for (const item of items) {
-      const fullPath = path.join(dir, item);
-      const relativeItemPath = path
-        .join(relativePath, item)
-        .replace(/\\/g, "/");
-      const stat = fs.statSync(fullPath);
-
-      // Check exclude patterns
-      const shouldExclude = excludePatterns.some((pattern) => {
-        const regex = new RegExp(
-          pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*"),
-        );
-        return regex.test(relativeItemPath) || regex.test(fullPath);
-      });
-
-      if (shouldExclude) {
-        continue;
-      }
-
-      if (stat.isDirectory()) {
-        walkDir(fullPath, relativeItemPath);
-      } else if (stat.isFile()) {
-        const ext = path.extname(item).toLowerCase();
-        const matchesInclude = includePatterns.some((pattern) => {
-          const regex = new RegExp(
-            pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*"),
-          );
-          return (
-            regex.test(relativeItemPath) || ext === ".md" || ext === ".mdx"
-          );
-        });
-
-        if (matchesInclude && (ext === ".md" || ext === ".mdx")) {
-          files.push({
-            fullPath,
-            relativePath: relativeItemPath,
-          });
-        }
-      }
-    }
-  }
-
-  walkDir(rootPath);
-  return files;
-}
-
 /**
  * Parse frontmatter from markdown content
  */
@@ -1268,7 +1458,18 @@ function parseFrontmatter(content) {
 }
 
 async function publishCommand(options = {}) {
-  const { tag, message, dryRun, force, video, outputJson } = options;
+  const {
+    tag,
+    message,
+    dryRun,
+    force,
+    video,
+    allOutput = false,
+    outputJson,
+    autoApprove,
+    skipReleaseDoctor = false,
+    noExit = false,
+  } = options;
 
   // Result tracking for --output-json and programmatic callers
   const publishResult = {
@@ -1277,6 +1478,7 @@ async function publishCommand(options = {}) {
     assetsSkipped: 0,
     reviewQueueItems: 0,
     viewUrl: null,
+    releaseDoctor: null,
     tag: tag || null,
     dryRun: !!dryRun,
     timestamp: new Date().toISOString(),
@@ -1294,6 +1496,10 @@ async function publishCommand(options = {}) {
     console.log(chalk.yellow("🔍 DRY RUN MODE - No assets will be uploaded\n"));
   }
 
+  if (autoApprove) {
+    console.log(chalk.cyan("  ✅ Auto-approve enabled: visuals will be approved immediately\n"));
+  }
+
   // Read config + settings (if available)
   const settings = readSettingsSafe();
   let docSyncConfig = null;
@@ -1305,6 +1511,57 @@ async function publishCommand(options = {}) {
     );
   }
 
+  if (skipReleaseDoctor) {
+    publishResult.releaseDoctor = {
+      skipped: true,
+      success: true,
+    };
+  } else if (docSyncConfig) {
+    console.log(chalk.cyan("🧪 Running release doctor before publish...\n"));
+    const { runReleaseDoctor } = require("../lib/release-doctor");
+    const releaseDoctor = await runReleaseDoctor({});
+    publishResult.releaseDoctor = {
+      skipped: false,
+      success: releaseDoctor.ok,
+      reportPath: releaseDoctor.reportPath || null,
+    };
+
+    if (!releaseDoctor.ok) {
+      console.log(chalk.red("  ✖ Release doctor failed. Fix the issues below before publishing:\n"));
+      const blockingIssues = releaseDoctor.summary?.blockingIssues || [];
+      if (blockingIssues.length > 0) {
+        for (const issue of blockingIssues) {
+          const scope = issue.scope ? `${issue.scope}: ` : "";
+          console.log(chalk.red(`    ✖ ${scope}${issue.message}`));
+        }
+      } else {
+        console.log(chalk.red("    ✖ Release gate checks failed (see report for details)."));
+      }
+      const advisories = releaseDoctor.summary?.advisories || [];
+      for (const advisory of advisories) {
+        const scope = advisory.scope ? `${advisory.scope}: ` : "";
+        console.log(chalk.yellow(`    ⚠ ${scope}${advisory.message}`));
+      }
+      if (releaseDoctor.reportPath) {
+        console.log(chalk.gray(`\n    Full report: ${releaseDoctor.reportPath}`));
+      }
+      if (!noExit) process.exit(1);
+      return {
+        ...publishResult,
+        success: false,
+        error: "Release doctor failed",
+      };
+    }
+
+    console.log(chalk.green("  ✔ Release doctor passed\n"));
+  } else {
+    publishResult.releaseDoctor = {
+      skipped: true,
+      success: true,
+      reason: "config-unavailable",
+    };
+  }
+
   // Determine storage mode and validate configuration
   const storageConfig = docSyncConfig?.storage;
   const storageMode = getStorageMode(docSyncConfig);
@@ -1324,7 +1581,8 @@ async function publishCommand(options = {}) {
       console.log(chalk.red(`  • ${error}`));
     }
     console.log(getStorageSetupHelp(storageConfig?.type || "reshot"));
-    process.exit(1);
+    if (!noExit) process.exit(1);
+    return { ...publishResult, success: false, error: "Invalid storage configuration" };
   }
 
   // Resolve project context based on storage mode
@@ -1343,7 +1601,8 @@ async function publishCommand(options = {}) {
       );
       console.log(getStorageSetupHelp("s3"));
     }
-    process.exit(1);
+    if (!noExit) process.exit(1);
+    return { ...publishResult, success: false, error: error.message };
   }
 
   const { apiKey, projectId, storageMode: resolvedMode } = projectContext;
@@ -1368,8 +1627,6 @@ async function publishCommand(options = {}) {
   // Get feature toggles
   const features = docSyncConfig?._metadata?.features || {
     visuals: true,
-    docs: false,
-    changelog: true,
   };
 
   // Get git information
@@ -1388,7 +1645,7 @@ async function publishCommand(options = {}) {
       });
       console.log(chalk.green(`  ✔ Version tag "${tag}" created`));
       console.log(
-        chalk.gray(`    Pinned URL: cdn.reshot.dev/assets/{key}?tag=${tag}\n`),
+        chalk.gray(`    Pinned URL: cdn.reshot.dev/v1/assets/{projectId}/{visualKey}?tag=${tag}\n`),
       );
     } catch (tagError) {
       console.log(
@@ -1401,9 +1658,51 @@ async function publishCommand(options = {}) {
   if (features.visuals === true) {
     const projectRoot = process.cwd();
     const outputBaseDir = path.join(projectRoot, ".reshot", "output");
-    const screenshotFiles = fs.existsSync(outputBaseDir)
-      ? findAssetFiles(outputBaseDir)
-      : [];
+    let screenshotFiles = [];
+    let screenshotScopeLabel = "all-output";
+    if (fs.existsSync(outputBaseDir)) {
+      if (allOutput) {
+        screenshotFiles = findAssetFiles(outputBaseDir);
+      } else {
+        const usable = getLatestUsableRunManifest();
+        if (!usable) {
+          throw new Error(
+            "No run manifest with successful scenarios found. Run `reshot run` first or use `reshot publish --all-output` to publish from the full output tree.",
+          );
+        }
+        const { manifest: latestRunManifest, isFallback, isPartialSuccess } = usable;
+
+        if (isFallback) {
+          const age = latestRunManifest.generatedAt
+            ? `generated ${latestRunManifest.generatedAt}`
+            : "unknown age";
+          console.log(
+            chalk.yellow(
+              `\n  WARNING: Latest run has no successful scenarios. Falling back to older manifest (${age}).` +
+                `\n  The published screenshots may be STALE. Run \`reshot run\` to capture fresh screenshots.\n`,
+            ),
+          );
+        } else if (isPartialSuccess) {
+          const allScenarios = latestRunManifest.scenarios || [];
+          const failed = allScenarios.filter((s) => s.success === false);
+          const succeeded = allScenarios.filter((s) => s.success !== false);
+          console.log(
+            chalk.yellow(
+              `\n  WARNING: Latest run had partial failures (${succeeded.length} passed, ${failed.length} failed).` +
+                `\n  Publishing only the ${succeeded.length} successful scenario(s).` +
+                `\n  Failed: ${failed.map((s) => s.key).join(", ")}\n`,
+            ),
+          );
+        }
+
+        const manifestScoped = resolveManifestScopedScreenshotFiles(
+          outputBaseDir,
+          latestRunManifest,
+        );
+        screenshotFiles = manifestScoped.screenshotFiles;
+        screenshotScopeLabel = `${manifestScoped.mode}:${manifestScoped.scenarioCount}`;
+      }
+    }
     const screenshotGroups =
       screenshotFiles.length > 0
         ? groupAssetsByScenario(screenshotFiles, outputBaseDir)
@@ -1434,10 +1733,16 @@ async function publishCommand(options = {}) {
             ` (${screenshotFiles.length} screenshots, ${exportVideoFiles.length} videos)\n`,
         ),
       );
+      console.log(
+        chalk.gray(
+          `  Screenshot scope: ${allOutput ? "all historical output (--all-output)" : `latest successful run (${screenshotScopeLabel})`}\n`,
+        ),
+      );
 
       let successCount = 0;
       let failCount = 0;
       let skippedCount = 0;
+      let reviewPendingCount = 0;
       let viewUrl = null;
 
       // Load diff manifests for attaching diff data to screenshot assets
@@ -1477,12 +1782,14 @@ async function publishCommand(options = {}) {
               projectId,
               groupedAssets,
               docSyncConfig,
-              { commitHash, commitMessage, publishSessionId },
+              { commitHash, commitMessage, publishSessionId, tag },
               diffManifests,
+              { autoApprove },
             );
             successCount = result.successCount;
             failCount = result.failCount;
             skippedCount = result.skippedCount || 0;
+            reviewPendingCount = result.reviewPendingCount || 0;
             viewUrl = result.viewUrl || null;
           } catch (txError) {
             // Fall back to legacy flow if transactional fails
@@ -1496,7 +1803,8 @@ async function publishCommand(options = {}) {
               projectId,
               groupedAssets,
               docSyncConfig,
-              { commitHash, commitMessage, publishSessionId },
+              { commitHash, commitMessage, publishSessionId, tag },
+              { autoApprove },
             );
             successCount = result.successCount;
             failCount = result.failCount;
@@ -1508,7 +1816,8 @@ async function publishCommand(options = {}) {
             projectId,
             groupedAssets,
             docSyncConfig,
-            { commitHash, commitMessage, publishSessionId },
+            { commitHash, commitMessage, publishSessionId, tag },
+            { autoApprove },
           );
           successCount = result.successCount;
           failCount = result.failCount;
@@ -1532,164 +1841,75 @@ async function publishCommand(options = {}) {
       }
       if (failCount > 0) {
         console.log(chalk.red(`  ✖ Failed: ${failCount}`));
+        const failedKeys = viewUrl ? [] : (publishResult.failedUploadKeys || []);
+        if (failedKeys.length > 0) {
+          for (const key of failedKeys.slice(0, 5)) {
+            console.log(chalk.red(`    - ${key}`));
+          }
+          if (failedKeys.length > 5) {
+            console.log(chalk.red(`    ... and ${failedKeys.length - 5} more`));
+          }
+        }
       }
       if (viewUrl) {
         console.log(chalk.cyan(`\n  🔗 View in platform: ${viewUrl}`));
       }
 
-      // Helpful guidance about diff percentages
-      if (diffManifests && diffManifests.size > 0) {
-        console.log(
-          chalk.gray(
-            "\n  💡 Diff data included! View change percentages in the platform.",
-          ),
-        );
-      } else {
-        console.log(
-          chalk.gray(
-            "\n  💡 Tip: Run 'reshot run' before publish to see change percentages.",
-          ),
-        );
-      }
-    }
-  } else {
-    console.log(
-      chalk.yellow("  ⚠ Visual asset publishing is disabled for this project."),
-    );
-  }
-
-  // Stream B: Documentation
-  if (features.docs === true) {
-    console.log(chalk.cyan("\n📚 Publishing documentation...\n"));
-
-    if (!docSyncConfig || !docSyncConfig.docs) {
-      console.log(
-        chalk.yellow(
-          "  ⚠ No docs configuration found in docsync.config.json. Skipping docs stream.",
-        ),
-      );
-    } else {
-      const docsConfig = docSyncConfig.docs;
-      const docsRoot = docsConfig.root || "./docs";
-      const includePatterns = docsConfig.include || ["**/*.md", "**/*.mdx"];
-      const excludePatterns = docsConfig.exclude || [
-        "**/node_modules/**",
-        "**/.git/**",
-      ];
-
-      const docFiles = findDocFiles(docsRoot, includePatterns, excludePatterns);
-
-      if (docFiles.length === 0) {
-        console.log(
-          chalk.yellow("  ⚠ No documentation files found to publish."),
-        );
-      } else {
-        console.log(
-          chalk.cyan(`  Found ${docFiles.length} documentation file(s)\n`),
-        );
-
-        const docsPayload = [];
-        for (const docFile of docFiles) {
-          const content = fs.readFileSync(docFile.fullPath, "utf-8");
-          const { frontmatter, content: docContent } =
-            parseFrontmatter(content);
-
-          docsPayload.push({
-            path: docFile.relativePath,
-            content: docContent,
-            frontmatter:
-              Object.keys(frontmatter).length > 0 ? frontmatter : undefined,
-            status: frontmatter.status || "draft",
-          });
-        }
-
-        // Docs publishing requires platform (no BYOS support yet)
-        if (resolvedMode === "byos") {
-          console.log(
-            chalk.yellow(
-              "  ⚠ Documentation publishing requires Reshot platform.",
-            ),
-          );
+      if (!autoApprove && successCount > 0) {
+        // Only NEW/CHANGED captures await review; unchanged captures dedup to
+        // their existing (often already-approved) version and stay live. Report
+        // the accurate pending count so a re-publish doesn't look like it reset
+        // already-approved work (audit run-10 F1).
+        const pending = reviewPendingCount;
+        const keptLive = Math.max(0, successCount - pending);
+        if (pending > 0) {
           console.log(
-            chalk.gray(
-              "     Run 'reshot auth' to enable doc hosting with review workflow.",
+            chalk.cyan(
+              `\n  ℹ ${pending} new/changed visual${pending === 1 ? "" : "s"} awaiting review (PENDING)`,
             ),
           );
-        } else {
-          try {
-            const result = await apiClient.publishDocs(apiKey, {
-              projectId,
-              docs: docsPayload,
-            });
+          if (keptLive > 0) {
             console.log(
-              chalk.green(
-                `  ✔ Published ${result.created || 0} new doc(s), updated ${
-                  result.updated || 0
-                } doc(s)`,
+              chalk.gray(
+                `    ${keptLive} unchanged visual${keptLive === 1 ? "" : "s"} kept current state (live pointers preserved; no re-approval needed).`,
               ),
             );
-          } catch (error) {
-            console.log(
-              chalk.red(`  ✖ Failed to publish docs: ${error.message}`),
-            );
           }
-        }
-      }
-    }
-  } else {
-    console.log(
-      chalk.yellow(
-        "  ⚠ Documentation publishing is disabled for this project.",
-      ),
-    );
-  }
-
-  // Stream C: Changelog
-  if (features.changelog === true) {
-    // Changelog requires platform (no BYOS support)
-    if (resolvedMode === "byos") {
-      console.log(chalk.cyan("\n📝 Changelog drafts...\n"));
-      console.log(
-        chalk.yellow(
-          "  ⚠ Changelog requires Reshot platform for tracking and publishing.",
-        ),
-      );
-      console.log(
-        chalk.gray("     Run 'reshot auth' to enable changelog generation."),
-      );
-    } else {
-      console.log(chalk.cyan("\n📝 Posting changelog drafts...\n"));
-      const lastPublishedHash = settings?.lastPublishedCommitHash;
-      const recentCommits = getRecentCommits(lastPublishedHash);
-
-      if (recentCommits.length > 0) {
-        try {
-          await apiClient.postChangelogDrafts(projectId, recentCommits, apiKey);
           console.log(
-            chalk.green(
-              `  ✔ Posted ${recentCommits.length} changelog draft(s)`,
+            chalk.gray(
+              "    To skip review for first-time captures, re-run with `reshot publish --auto-approve`",
             ),
           );
-
-          // Update last published commit hash
-          if (settings) {
-            settings.lastPublishedCommitHash = commitHash;
-            config.writeSettings(settings);
-          }
-        } catch (error) {
           console.log(
-            chalk.yellow(
-              `  ⚠ Failed to post changelog drafts: ${error.message}`,
+            chalk.gray("    or approve them in the studio link above."),
+          );
+        } else {
+          console.log(
+            chalk.cyan(
+              `\n  ℹ No new captures to review — all ${successCount} published visual${successCount === 1 ? "" : "s"} were unchanged; existing live pointers are preserved (already-approved stay live, pending stay pending).`,
             ),
           );
         }
+      }
+
+      // Helpful guidance about diff percentages
+      if (diffManifests && diffManifests.size > 0) {
+        console.log(
+          chalk.gray(
+            "\n  💡 Diff data included! View change percentages in the platform.",
+          ),
+        );
       } else {
-        console.log(chalk.gray("  No new commits to publish"));
+        console.log(
+          chalk.gray(
+            "\n  💡 Tip: Run 'reshot run' before publish to see change percentages.",
+          ),
+        );
       }
     }
   } else {
     console.log(
-      chalk.yellow("  ⚠ Changelog publishing is disabled for this project."),
+      chalk.yellow("  ⚠ Visual asset publishing is disabled for this project."),
     );
   }
 
@@ -1700,7 +1920,7 @@ async function publishCommand(options = {}) {
     console.log(chalk.gray("   • Unbreakable URLs that never change"));
     console.log(chalk.gray("   • Version history and rollback"));
     console.log(chalk.gray("   • Team collaboration and RBAC"));
-    console.log(chalk.gray("   • Automatic changelog generation"));
+    console.log(chalk.gray("   • Drift detection and notifications"));
     console.log(chalk.gray("\n   Run 'reshot auth' to connect your project."));
   }
 
@@ -1715,7 +1935,14 @@ async function publishCommand(options = {}) {
 
   console.log();
 
-  return publishResult;
+  return {
+    ...publishResult,
+    success: publishResult.assetsFailed === 0 && publishResult.assetsProcessed > 0,
+  };
 }
 
 module.exports = publishCommand;
+module.exports.groupAssetsByScenario = groupAssetsByScenario;
+module.exports.resolveManifestScopedScreenshotFiles =
+  resolveManifestScopedScreenshotFiles;
+module.exports.collectAssetFilesFromDirectories = collectAssetFilesFromDirectories;