@julioventura/opensquad 0.1.17

package/skills/run-dashboard/scripts/generate.js

@@ -0,0 +1,1296 @@
+import { copyFile, mkdir, mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { dirname, extname, join, relative, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { Client as FtpClient } from 'basic-ftp';
+import { resolveConfiguredEnv as resolveInstagramEnv, resolveFacebookPageAccessToken } from '../../instagram-publisher/scripts/publish.js';
+import { resolveConfiguredEnv as resolveYouTubeEnv, exchangeRefreshToken } from '../../youtube-publisher/scripts/publish.js';
+import { ensureRunStateFile } from './finalize-state.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const DEFAULT_ARGS = {
+  runDir: '',
+  workspaceRoot: process.cwd(),
+  outputHtml: '',
+  outputJson: '',
+  templatePath: join(__dirname, '..', 'templates', 'run-dashboard.template.html'),
+  refreshMetrics: false,
+  publishStatic: false,
+  publishDir: '',
+  publishDirEnv: '',
+  publishUrlBase: '',
+  publishLatestName: '',
+};
+
+const RUN_FILE_PATHS = {
+  state: ['state.json'],
+  publishResult: ['publish-result.md', 'v1/publish-result.md'],
+  editorialPlan: ['editorial-plan.md', 'v1/editorial-plan.md'],
+  researchBrief: ['research-brief.md', 'v1/research-brief.md'],
+  contentPackage: ['content-package.md', 'v1/content-package.md'],
+  images: ['images.md', 'v1/images.md'],
+  review: ['review.md', 'v1/review.md'],
+  publishConfig: ['publish-config.md', 'v1/publish-config.md'],
+  preImageApproval: ['pre-image-approval.md', 'v1/pre-image-approval.md'],
+  newsletterImageManifest: ['newsletter-image-urls.json', 'v1/newsletter-image-urls.json'],
+  newsletterHtml: ['newsletter.html', 'v1/newsletter.html'],
+  newsletterText: ['newsletter.txt', 'v1/newsletter.txt'],
+  newsletterPreview: ['newsletter-preview.md', 'v1/newsletter-preview.md'],
+  sendPreview: ['send-preview.md', 'v1/send-preview.md'],
+  emailSendResult: ['email-send-result.md', 'v1/email-send-result.md'],
+};
+
+function parseArgs(argv) {
+  const args = { ...DEFAULT_ARGS };
+
+  for (let index = 2; index < argv.length; index += 1) {
+    const current = argv[index];
+    if (current === '--run-dir' && index + 1 < argv.length) args.runDir = argv[++index];
+    else if (current === '--workspace-root' && index + 1 < argv.length) args.workspaceRoot = argv[++index];
+    else if (current === '--output-html' && index + 1 < argv.length) args.outputHtml = argv[++index];
+    else if (current === '--output-json' && index + 1 < argv.length) args.outputJson = argv[++index];
+    else if (current === '--template-path' && index + 1 < argv.length) args.templatePath = argv[++index];
+    else if (current === '--no-refresh-metrics') args.refreshMetrics = false;
+    else if (current === '--refresh-metrics') args.refreshMetrics = true;
+    else if (current === '--publish-static') args.publishStatic = true;
+    else if (current === '--publish-dir' && index + 1 < argv.length) args.publishDir = argv[++index];
+    else if (current === '--publish-dir-env' && index + 1 < argv.length) args.publishDirEnv = argv[++index];
+    else if (current === '--publish-url-base' && index + 1 < argv.length) args.publishUrlBase = argv[++index];
+    else if (current === '--publish-latest-name' && index + 1 < argv.length) args.publishLatestName = argv[++index];
+  }
+
+  return args;
+}
+
+async function main() {
+  const args = parseArgs(process.argv);
+  if (!args.runDir) throw new Error('--run-dir is required');
+
+  const runDir = resolve(args.runDir);
+  const workspaceRoot = resolve(args.workspaceRoot);
+  const outputJson = resolve(args.outputJson || join(runDir, 'run-dashboard.data.json'));
+  const outputHtml = resolve(args.outputHtml || join(runDir, 'run-dashboard.html'));
+  const envVars = await loadEnvVars(workspaceRoot);
+  const squadName = inferSquadName(runDir);
+  const channelConfig = await loadChannelConfig(workspaceRoot, squadName);
+
+  const dashboardFiles = await writeDashboardFiles({
+    runDir,
+    workspaceRoot,
+    outputHtml,
+    outputJson,
+    templatePath: resolve(args.templatePath),
+    refreshMetrics: args.refreshMetrics,
+  });
+
+  const staticPublish = resolveStaticPublishOptions({
+    args,
+    envVars,
+    channelConfig,
+  });
+
+  if (staticPublish.enabled) {
+    const published = await publishStaticDashboardSnapshot({
+      payload: dashboardFiles.payload,
+      runDir,
+      templatePath: resolve(args.templatePath),
+      publishDir: staticPublish.publishDir,
+      ftpRemoteDir: staticPublish.ftpRemoteDir,
+      publicBaseUrl: staticPublish.publicBaseUrl,
+      latestFileName: staticPublish.latestFileName,
+      transport: staticPublish.transport,
+      ftpConfig: staticPublish.ftpConfig,
+    });
+
+    console.log(`Run dashboard latest snapshot published to ${published.latestPath}`);
+    console.log(`Run dashboard archive snapshot published to ${published.archivePath}`);
+    if (published.latestUrl) console.log(`Run dashboard latest URL: ${published.latestUrl}`);
+    if (published.archiveUrl) console.log(`Run dashboard archive URL: ${published.archiveUrl}`);
+    if (published.latestYouTubeShareUrl) console.log(`Run dashboard YouTube share URL: ${published.latestYouTubeShareUrl}`);
+    if (published.archiveYouTubeShareUrl) console.log(`Run dashboard YouTube share archive URL: ${published.archiveYouTubeShareUrl}`);
+  }
+
+  console.log(`Run dashboard written to ${outputHtml}`);
+  console.log(`Run dashboard data written to ${outputJson}`);
+}
+
+export async function writeDashboardFiles(options) {
+  const payload = await buildRunDashboardPayload(options);
+  const html = await renderDashboardHtml({
+    templatePath: options.templatePath,
+    payload,
+    dataFileName: options.outputJson.split(/[/\\]/).pop(),
+  });
+
+  await writeFile(options.outputJson, `${JSON.stringify(payload, null, 2)}\n`, 'utf-8');
+  await writeFile(options.outputHtml, html, 'utf-8');
+
+  return { payload, html, outputHtml: options.outputHtml, outputJson: options.outputJson };
+}
+
+export async function buildRunDashboardPayload(options) {
+  const { runDir, workspaceRoot, refreshMetrics } = options;
+  await ensureRunStateFile({ runDir, workspaceRoot, force: false, strict: false });
+  const envVars = await loadEnvVars(workspaceRoot);
+  const runFiles = await loadRunFiles(runDir);
+  const squadName = inferSquadName(runDir);
+  const publish = parsePublishResult(runFiles.publishResult);
+  const state = parseState(runFiles.state);
+  const runContext = inferRunContext(runDir, { state, publish });
+  const runId = runContext.runId;
+  const channelConfig = await loadChannelConfig(workspaceRoot, squadName);
+  const theme = extractTheme(runFiles.editorialPlan) || extractTheme(runFiles.researchBrief);
+  const errors = buildErrorList({ publish, state, images: runFiles.images, review: runFiles.review });
+  const metrics = refreshMetrics
+    ? await collectMetrics({ publish, envVars, channelConfig })
+    : [];
+  const previews = await buildVisualPreviews(runDir, publish, runFiles.contentPackage);
+
+  return {
+    title: theme || squadName,
+    subtitle: buildSubtitle({ publish, squadName, runId }),
+    squad: squadName,
+    runId,
+    runContext,
+    status: publish.status || state.status || 'unknown',
+    startedAt: state.startedAt || null,
+    updatedAt: publish.publishedAt || state.completedAt || state.updatedAt || null,
+    lastRefreshedAt: new Date().toISOString(),
+    checklist: buildChecklist({ state, runFiles, publish, runContext }),
+    channels: buildChannels(publish),
+    artifacts: buildArtifacts(runDir, runFiles),
+    previews,
+    metrics,
+    metricsNote: buildMetricsNote(metrics, runContext),
+    errors,
+    refresh: {
+      endpoint: '__run_dashboard_refresh__',
+      liveModeLabel: 'Use o servidor local do dashboard para regenerar métricas em tempo real.',
+    },
+  };
+}
+
+export async function renderDashboardHtml(options) {
+  const template = await readFile(options.templatePath, 'utf-8');
+  return template
+    .replace('__RUN_DASHBOARD_BOOTSTRAP__', escapeScriptJson(JSON.stringify(options.payload, null, 2)))
+    .replace('__RUN_DASHBOARD_JSON_PATH__', options.dataFileName || 'run-dashboard.data.json');
+}
+
+export function resolveStaticPublishOptions({ args, envVars, channelConfig }) {
+  const publishConfig = channelConfig?.dashboard?.static_publish || {};
+  const requested = Boolean(
+    args.publishStatic
+    || args.publishDir
+    || args.publishDirEnv
+    || args.publishUrlBase
+    || args.publishLatestName
+    || publishConfig.enabled,
+  );
+
+  if (!requested) {
+    return {
+      enabled: false,
+      transport: 'local',
+      publishDir: '',
+      publicBaseUrl: '',
+      latestFileName: 'index.html',
+      ftpConfig: null,
+    };
+  }
+
+  const publishDirEnvKey = args.publishDirEnv || publishConfig.publish_dir_env || '';
+  const rawPublishDir = args.publishDir || (publishDirEnvKey ? envVars[publishDirEnvKey] || '' : '');
+  const ftpConfig = resolveStaticPublishFtpConfig({ envVars, publishConfig });
+  const configTransport = (publishConfig.transport || '').toLowerCase();
+  const transport = configTransport === 'both' ? 'both' : (configTransport === 'ftp' || ftpConfig ? 'ftp' : 'local');
+  const publishDir = transport === 'ftp' ? rawPublishDir : resolve(rawPublishDir);
+  const ftpRemoteDir = rawPublishDir;
+
+  if (!publishDir || ((transport === 'local' || transport === 'both') && publishDir === resolve(''))) {
+    throw new Error(`Static dashboard publish requested, but no publish directory was resolved. Checked --publish-dir and env key '${publishDirEnvKey || 'not provided'}'.`);
+  }
+
+  return {
+    enabled: true,
+    transport,
+    publishDir,
+    ftpRemoteDir,
+    publicBaseUrl: normalizePublicBaseUrl(args.publishUrlBase || publishConfig.public_base_url || ''),
+    latestFileName: sanitizeFileName(args.publishLatestName || publishConfig.latest_file_name || 'index.html'),
+    ftpConfig,
+  };
+}
+
+export async function publishStaticDashboardSnapshot(options) {
+  const {
+    payload,
+    runDir,
+    templatePath,
+    publishDir,
+    ftpRemoteDir = '',
+    publicBaseUrl = '',
+    latestFileName = 'index.html',
+    transport = 'local',
+    ftpConfig = null,
+    uploadViaFtpImpl = uploadDirectoryViaFtp,
+  } = options;
+  const runId = sanitizeFileName(payload?.runId || 'snapshot');
+  const latestVariant = 'latest';
+  const archiveVariant = runId;
+  const latestDataFileName = 'run-dashboard.data.json';
+  const archiveDataFileName = `${runId}.data.json`;
+  const workingPublishDir = transport === 'ftp'
+    ? await mkdtemp(join(tmpdir(), 'opensquad-dashboard-publish-'))
+    : publishDir;
+  const latestPayload = await rewritePayloadForStaticPublish({ payload, runDir, publishDir: workingPublishDir, variantName: latestVariant });
+  const archivePayload = await rewritePayloadForStaticPublish({ payload, runDir, publishDir: workingPublishDir, variantName: archiveVariant });
+  const latestHtml = await renderDashboardHtml({ templatePath, payload: latestPayload, dataFileName: latestDataFileName });
+  const archiveHtml = await renderDashboardHtml({ templatePath, payload: archivePayload, dataFileName: archiveDataFileName });
+  const latestPath = join(workingPublishDir, latestFileName);
+  const archiveFileName = `${runId}.html`;
+  const archivePath = join(workingPublishDir, archiveFileName);
+  const latestDataPath = join(workingPublishDir, latestDataFileName);
+  const archiveDataPath = join(workingPublishDir, archiveDataFileName);
+  const latestYouTubeShareFileName = 'youtube.html';
+  const archiveYouTubeShareFileName = `${runId}-youtube.html`;
+  const latestYouTubeSharePath = join(workingPublishDir, latestYouTubeShareFileName);
+  const archiveYouTubeSharePath = join(workingPublishDir, archiveYouTubeShareFileName);
+
+  await mkdir(dirname(latestPath), { recursive: true });
+  await mkdir(dirname(archivePath), { recursive: true });
+  await writeFile(latestPath, latestHtml, 'utf-8');
+  await writeFile(archivePath, archiveHtml, 'utf-8');
+  await writeFile(latestDataPath, `${JSON.stringify(latestPayload, null, 2)}\n`, 'utf-8');
+  await writeFile(archiveDataPath, `${JSON.stringify(archivePayload, null, 2)}\n`, 'utf-8');
+
+  const latestYouTubeSharePage = buildYouTubeSharePage({
+    payload: latestPayload,
+    ogUrl: publicBaseUrl ? `${publicBaseUrl}${latestYouTubeShareFileName}` : null,
+  });
+  if (latestYouTubeSharePage) {
+    await writeFile(latestYouTubeSharePath, latestYouTubeSharePage, 'utf-8');
+  }
+
+  const archiveYouTubeSharePage = buildYouTubeSharePage({
+    payload: archivePayload,
+    ogUrl: publicBaseUrl ? `${publicBaseUrl}${archiveYouTubeShareFileName}` : null,
+  });
+  if (archiveYouTubeSharePage) {
+    await writeFile(archiveYouTubeSharePath, archiveYouTubeSharePage, 'utf-8');
+  }
+
+  if (transport === 'ftp' || transport === 'both') {
+    if (!ftpConfig) {
+      throw new Error('FTP static publish requested, but FTP credentials were not resolved.');
+    }
+
+    try {
+      await uploadViaFtpImpl({
+        localDir: workingPublishDir,
+        remoteDir: transport === 'both' ? ftpRemoteDir : publishDir,
+        ftpConfig,
+      });
+    } finally {
+      if (transport === 'ftp') {
+        await rm(workingPublishDir, { recursive: true, force: true });
+      }
+    }
+  }
+
+  return {
+    latestPath: transport === 'ftp' ? join(publishDir, latestFileName) : latestPath,
+    archivePath: transport === 'ftp' ? join(publishDir, archiveFileName) : archivePath,
+    latestDataPath: transport === 'ftp' ? join(publishDir, latestDataFileName) : latestDataPath,
+    archiveDataPath: transport === 'ftp' ? join(publishDir, archiveDataFileName) : archiveDataPath,
+    latestUrl: publicBaseUrl ? `${publicBaseUrl}${latestFileName}` : null,
+    archiveUrl: publicBaseUrl ? `${publicBaseUrl}${archiveFileName}` : null,
+    latestDataUrl: publicBaseUrl ? `${publicBaseUrl}${latestDataFileName}` : null,
+    archiveDataUrl: publicBaseUrl ? `${publicBaseUrl}${archiveDataFileName}` : null,
+    latestYouTubeSharePath: latestYouTubeSharePage
+      ? (transport === 'ftp' ? join(publishDir, latestYouTubeShareFileName) : latestYouTubeSharePath)
+      : null,
+    archiveYouTubeSharePath: archiveYouTubeSharePage
+      ? (transport === 'ftp' ? join(publishDir, archiveYouTubeShareFileName) : archiveYouTubeSharePath)
+      : null,
+    latestYouTubeShareUrl: latestYouTubeSharePage && publicBaseUrl ? `${publicBaseUrl}${latestYouTubeShareFileName}` : null,
+    archiveYouTubeShareUrl: archiveYouTubeSharePage && publicBaseUrl ? `${publicBaseUrl}${archiveYouTubeShareFileName}` : null,
+  };
+}
+
+function buildYouTubeSharePage({ payload, ogUrl }) {
+  if (!payload || !Array.isArray(payload.channels)) return null;
+
+  const youtubeChannel = payload.channels.find((channel) => String(channel?.name || '').toLowerCase() === 'youtube');
+  const youtubeLink = youtubeChannel?.links?.find((link) => isYouTubeLink(link?.href))?.href || null;
+  if (!youtubeLink) return null;
+
+  const thumbnail = Array.isArray(payload.previews)
+    ? payload.previews.find((preview) => String(preview?.type || '').toLowerCase() === 'thumbnail')
+    : null;
+
+  const imageHref = thumbnail?.src || null;
+  const title = payload?.title ? `${payload.title} · YouTube` : 'YouTube Video';
+  const description = payload?.subtitle
+    || youtubeChannel?.summary
+    || 'Abra o vídeo publicado desta run no YouTube.';
+
+  return renderOgRedirectHtml({
+    title,
+    description,
+    ogUrl: ogUrl || youtubeLink,
+    imageHref,
+    redirectUrl: youtubeLink,
+  });
+}
+
+function renderOgRedirectHtml({ title, description, ogUrl, imageHref, redirectUrl }) {
+  const safeTitle = escapeHtml(title || 'YouTube Video');
+  const safeDescription = escapeHtml(description || 'Abra o vídeo publicado desta run no YouTube.');
+  const safeOgUrl = escapeHtml(ogUrl || redirectUrl || '');
+  const safeImage = imageHref ? escapeHtml(imageHref) : '';
+  const safeRedirect = escapeHtml(redirectUrl || '');
+
+  return `<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${safeTitle}</title>
+  <meta name="description" content="${safeDescription}">
+  <meta property="og:title" content="${safeTitle}">
+  <meta property="og:description" content="${safeDescription}">
+  <meta property="og:type" content="video.other">
+  <meta property="og:url" content="${safeOgUrl}">
+  ${safeImage ? `<meta property="og:image" content="${safeImage}">` : ''}
+  <meta name="twitter:card" content="summary_large_image">
+  <meta name="twitter:title" content="${safeTitle}">
+  <meta name="twitter:description" content="${safeDescription}">
+  ${safeImage ? `<meta name="twitter:image" content="${safeImage}">` : ''}
+  ${safeRedirect ? `<meta http-equiv="refresh" content="0; url=${safeRedirect}">` : ''}
+</head>
+<body>
+  <p>Redirecionando para o vídeo no YouTube...</p>
+  ${safeRedirect ? `<p><a href="${safeRedirect}">Abrir vídeo</a></p>` : ''}
+</body>
+</html>
+`;
+}
+
+function isYouTubeLink(value) {
+  return /^https?:\/\/(?:www\.)?(?:youtube\.com\/watch\?v=|youtu\.be\/)/i.test(String(value || ''));
+}
+
+function escapeHtml(value) {
+  return String(value || '')
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+function resolveStaticPublishFtpConfig({ envVars, publishConfig }) {
+  const ftpSection = publishConfig?.ftp || {};
+  const hostKey = ftpSection.host_env || '';
+  const portKey = ftpSection.port_env || '';
+  const userKey = ftpSection.user_env || '';
+  const passKey = ftpSection.pass_env || '';
+
+  if (!hostKey && !portKey && !userKey && !passKey) return null;
+
+  const host = hostKey ? envVars[hostKey] || '' : '';
+  const port = portKey ? Number(envVars[portKey] || 21) : 21;
+  const user = userKey ? envVars[userKey] || '' : '';
+  const password = passKey ? envVars[passKey] || '' : '';
+
+  if (!host || !user) {
+    throw new Error(`FTP static publish is configured, but required credentials are missing. Checked env keys '${hostKey}' and '${userKey}'.`);
+  }
+
+  return {
+    host,
+    port,
+    user,
+    password,
+  };
+}
+
+async function uploadDirectoryViaFtp({ localDir, remoteDir, ftpConfig }) {
+  const client = new FtpClient();
+
+  try {
+    await client.access({
+      host: ftpConfig.host,
+      port: Number(ftpConfig.port) || 21,
+      user: ftpConfig.user,
+      password: ftpConfig.password,
+      secure: true,
+      secureOptions: { rejectUnauthorized: false },
+    });
+    await client.ensureDir(String(remoteDir).replace(/\\/g, '/'));
+    await client.uploadFromDir(localDir, String(remoteDir).replace(/\\/g, '/'));
+  } finally {
+    client.close();
+  }
+}
+
+async function loadRunFiles(runDir) {
+  const entries = {};
+  for (const [key, relativePaths] of Object.entries(RUN_FILE_PATHS)) {
+    entries[key] = await firstExistingFile(runDir, relativePaths);
+  }
+  return entries;
+}
+
+async function firstExistingFile(runDir, relativePaths) {
+  for (const relativePath of relativePaths) {
+    const absolutePath = join(runDir, relativePath);
+    if (!existsSync(absolutePath)) continue;
+    return {
+      path: absolutePath,
+      relativePath,
+      content: await readFile(absolutePath, 'utf-8'),
+    };
+  }
+  return null;
+}
+
+function inferSquadName(runDir) {
+  const normalized = runDir.replace(/\\/g, '/');
+  const parts = normalized.split('/');
+  const squadsIndex = parts.lastIndexOf('squads');
+  return squadsIndex !== -1 ? parts[squadsIndex + 1] : 'unknown-squad';
+}
+
+function inferRunContext(runDir, context = {}) {
+  const normalized = runDir.replace(/\\/g, '/');
+  const parts = normalized.split('/').filter(Boolean);
+  const leaf = parts.at(-1) || 'unknown-run';
+  const parent = parts.at(-2) || null;
+
+  if (isTimestampLikeRunId(leaf)) {
+    return { runId: leaf, isLegacyOutputRoot: false, source: 'folder-name' };
+  }
+
+  if (/^v\d+$/i.test(leaf) && parent && isTimestampLikeRunId(parent)) {
+    return { runId: parent, isLegacyOutputRoot: false, source: 'version-folder' };
+  }
+
+  if (leaf === 'output' || leaf === 'archive') {
+    const derivedFromState = formatRunIdFromDate(context.state?.startedAt || context.state?.completedAt || context.state?.updatedAt);
+    if (derivedFromState) {
+      return { runId: derivedFromState, isLegacyOutputRoot: true, source: 'state-timestamp' };
+    }
+
+    const derivedFromPublish = formatRunIdFromDate(context.publish?.publishedAt);
+    if (derivedFromPublish) {
+      return { runId: derivedFromPublish, isLegacyOutputRoot: true, source: 'publish-timestamp' };
+    }
+
+    return { runId: 'legacy-output-root', isLegacyOutputRoot: true, source: 'legacy-output-root' };
+  }
+
+  return { runId: leaf, isLegacyOutputRoot: false, source: 'folder-name' };
+}
+
+function isTimestampLikeRunId(value) {
+  return /^\d{4}-\d{2}-\d{2}-\d{6}$/.test(value || '');
+}
+
+function formatRunIdFromDate(value) {
+  if (!value) return null;
+  const isoLikeMatch = String(value).match(/^(\d{4})-(\d{2})-(\d{2})[T\s](\d{2}):(\d{2}):(\d{2})/);
+  if (isoLikeMatch) {
+    const [, year, month, day, hours, minutes, seconds] = isoLikeMatch;
+    return `${year}-${month}-${day}-${hours}${minutes}${seconds}`;
+  }
+
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return null;
+
+  const year = String(date.getFullYear());
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  const hours = String(date.getHours()).padStart(2, '0');
+  const minutes = String(date.getMinutes()).padStart(2, '0');
+  const seconds = String(date.getSeconds()).padStart(2, '0');
+
+  return `${year}-${month}-${day}-${hours}${minutes}${seconds}`;
+}
+
+function parseState(file) {
+  if (!file?.content) return {};
+  try {
+    return JSON.parse(file.content);
+  } catch {
+    return {};
+  }
+}
+
+function parsePublishResult(file) {
+  const content = file?.content || '';
+  return {
+    status: extractLabeledValue(content, 'Status'),
+    instagramPostId: extractLabeledValue(content, 'Instagram Post ID'),
+    instagramUrl: extractLabeledValue(content, 'Instagram URL'),
+    facebookPostId: extractLabeledValue(content, 'Facebook Post ID'),
+    facebookUrl: extractLabeledValue(content, 'Facebook URL'),
+    youtubeVideoId: extractLabeledValue(content, 'YouTube Video ID'),
+    youtubeUrl: extractLabeledValue(content, 'YouTube URL'),
+    youtubeThumbnail: extractLabeledValue(content, 'YouTube Thumbnail'),
+    youtubePlaylist: extractLabeledValue(content, 'YouTube Playlist'),
+    publishedAt: extractLabeledValue(content, 'Publicado em'),
+    error: extractLabeledValue(content, 'Erro remanescente'),
+    newsletterStatus: extractLabeledValue(content, 'Newsletter Status'),
+    newsletterMode: extractLabeledValue(content, 'Newsletter Mode'),
+    newsletterBrand: extractLabeledValue(content, 'Newsletter Brand'),
+    newsletterSubject: extractLabeledValue(content, 'Newsletter Subject'),
+    newsletterTo: extractLabeledValue(content, 'Newsletter To'),
+    newsletterHtml: extractLabeledValue(content, 'Newsletter HTML'),
+    newsletterResult: extractLabeledValue(content, 'Newsletter Result'),
+    newsletterNotes: extractLabeledValue(content, 'Newsletter Notes'),
+  };
+}
+
+function extractLabeledValue(content, label) {
+  const escapedLabel = label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const match = content.match(new RegExp(`\\*\\*${escapedLabel}:\\*\\*\\s*(.+)`, 'i'));
+  return match ? sanitizeValue(match[1]) : null;
+}
+
+function sanitizeValue(value) {
+  if (!value) return null;
+  const normalized = value
+    .replace(/^\*\*|\*\*$/g, '')
+    .replace(/^__|__$/g, '')
+    .replace(/^`|`$/g, '')
+    .replace(/^<|>$/g, '')
+    .trim();
+  const markdownLinkMatch = normalized.match(/^\[[^\]]+\]\(([^)]+)\)$/);
+  const unwrapped = markdownLinkMatch ? markdownLinkMatch[1].trim() : normalized;
+  if (!unwrapped || unwrapped.toLowerCase() === 'null' || unwrapped === 'N/A') return null;
+  return unwrapped;
+}
+
+function extractTheme(file) {
+  const content = file?.content || '';
+  const directPatterns = [
+    /\*\*Tema Central:\*\*\s*(.+)/i,
+    /\*\*Tema central da semana:\*\*\s*(.+)/i,
+    /\*\*Tema:\*\*\s*(.+)/i,
+  ];
+
+  for (const pattern of directPatterns) {
+    const match = content.match(pattern);
+    if (match) return sanitizeValue(match[1]);
+  }
+
+  const lines = content.split(/\r?\n/);
+  const heading = lines.find((line) => /^#\s+/.test(line.trim()));
+  return heading ? sanitizeValue(heading.replace(/^#\s+/, '')) : null;
+}
+
+function buildSubtitle({ publish, squadName, runId }) {
+  const parts = [squadName, runId].filter(Boolean);
+  if (publish.publishedAt) parts.push(`publicado em ${publish.publishedAt}`);
+  return parts.join(' · ');
+}
+
+function buildChecklist({ state, runFiles, publish, runContext }) {
+  const reviewDecision = extractLabeledValue(runFiles.review?.content || '', 'Decision');
+  const imagesStatus = extractLabeledValue(runFiles.images?.content || '', 'Status');
+  const publishConfigPlatforms = extractLabeledValue(runFiles.publishConfig?.content || '', 'Plataformas');
+  const complementaryDistribution = extractLabeledValue(runFiles.publishConfig?.content || '', 'Distribuição complementar');
+  const newsletterRecipient = extractLabeledValue(runFiles.publishConfig?.content || '', 'Newsletter destinatário teste');
+  const finalStateDescription = state.completedAt || state.failedAt
+    ? `Finalizado em ${state.completedAt || state.failedAt}`
+    : runContext.isLegacyOutputRoot && publish.publishedAt
+      ? `Run legada sem state.json; usando snapshot publicado em ${publish.publishedAt}.`
+      : 'State final não encontrado.';
+  const finalStateStatus = state.status ? 'ok' : runContext.isLegacyOutputRoot ? 'warn' : 'warn';
+  const finalStateBadge = state.status || (runContext.isLegacyOutputRoot ? 'legacy snapshot' : 'unknown');
+  const finalStateIcon = state.status === 'completed' ? 'OK' : runContext.isLegacyOutputRoot ? 'LG' : '??';
+
+  const checklist = [
+    {
+      title: 'Revisão de qualidade consolidada',
+      description: reviewDecision ? `Veredito da revisão: ${reviewDecision}` : 'Arquivo de review não encontrado ou sem decisão explícita.',
+      status: reviewDecision && reviewDecision.toLowerCase() === 'aprovar' ? 'ok' : 'warn',
+      badge: reviewDecision && reviewDecision.toLowerCase() === 'aprovar' ? 'approved' : (reviewDecision || 'pending'),
+      badgeLabel: reviewDecision && reviewDecision.toLowerCase() === 'aprovar' ? 'APROVADO' : (reviewDecision || 'pending'),
+      icon: reviewDecision && reviewDecision.toLowerCase() === 'aprovar' ? 'OK' : '!!',
+    },
+    {
+      title: 'Imagens/render aprovados',
+      description: imagesStatus ? `Manifesto de imagens em estado ${imagesStatus}.` : 'Manifesto de imagens não localizado.',
+      status: imagesStatus && imagesStatus.toLowerCase() === 'approved' ? 'ok' : 'warn',
+      badge: imagesStatus || 'missing',
+      badgeLabel: imagesStatus || 'missing',
+      icon: imagesStatus && imagesStatus.toLowerCase() === 'approved' ? 'OK' : '!!',
+    },
+    {
+      title: 'Configuração de publicação registrada',
+      description: publishConfigPlatforms ? `Plataformas aprovadas: ${publishConfigPlatforms}` : 'Configuração de publicação não encontrada.',
+      status: publishConfigPlatforms ? 'ok' : 'warn',
+      badge: publishConfigPlatforms ? 'recorded' : 'missing',
+      badgeLabel: publishConfigPlatforms ? 'recorded' : 'missing',
+      icon: publishConfigPlatforms ? 'OK' : '!!',
+    },
+    {
+      title: 'Resultado operacional consolidado',
+      description: publish.status ? `Publicação final em estado ${publish.status}.` : 'publish-result.md não encontrado.',
+      status: publish.status ? (publish.status.toLowerCase() === 'published' ? 'ok' : publish.status.toLowerCase()) : 'warn',
+      badge: publish.status || 'missing',
+      badgeLabel: publish.status || 'missing',
+      icon: publish.status && publish.status.toLowerCase() === 'published' ? 'OK' : '!!',
+    },
+  ];
+
+  if ((complementaryDistribution || '').toLowerCase() === 'jornal-matutino' || publish.newsletterStatus) {
+    const newsletterStatus = (publish.newsletterStatus || 'pending').toLowerCase();
+    checklist.push({
+      title: 'Distribuição complementar do jornal-matutino',
+      description: publish.newsletterStatus
+        ? `Resultado complementar em estado ${publish.newsletterStatus}${publish.newsletterTo ? ` para ${publish.newsletterTo}` : ''}.`
+        : `Distribuição complementar registrada${newsletterRecipient ? ` para ${newsletterRecipient}` : ''}, aguardando execução do step final.`,
+      status: newsletterStatus === 'sent' ? 'ok' : newsletterStatus === 'failed' ? 'error' : 'warn',
+      badge: publish.newsletterStatus || complementaryDistribution || 'pending',
+      badgeLabel: publish.newsletterStatus || complementaryDistribution || 'pending',
+      icon: newsletterStatus === 'sent' ? 'OK' : newsletterStatus === 'failed' ? 'XX' : '!!',
+    });
+  }
+
+  checklist.push({
+    title: 'Estado final da pipeline registrado',
+    description: finalStateDescription,
+    status: finalStateStatus,
+    badge: finalStateBadge,
+    badgeLabel: finalStateBadge,
+    icon: finalStateIcon,
+  });
+
+  return checklist;
+}
+
+function buildChannels(publish) {
+  return [
+    buildChannel('Instagram', publish.instagramUrl, publish.instagramPostId, publish.instagramUrl ? 'published' : publish.status === 'partial' ? 'partial' : 'missing', 'Post publicado no feed ou carrossel do Instagram.'),
+    buildChannel('Facebook', publish.facebookUrl, publish.facebookPostId, publish.facebookUrl ? 'published' : publish.status === 'partial' ? 'partial' : 'missing', 'Cross-post ou publicação da Página do Facebook.'),
+    buildChannel('YouTube', publish.youtubeUrl, publish.youtubeVideoId, publish.youtubeUrl ? 'published' : 'missing', publish.youtubePlaylist ? `Vídeo adicionado à playlist ${publish.youtubePlaylist}.` : 'Vídeo/slideshow publicado no YouTube.'),
+    buildNewsletterChannel(publish),
+  ].filter(Boolean);
+}
+
+function buildNewsletterChannel(publish) {
+  if (!publish.newsletterStatus && !publish.newsletterSubject && !publish.newsletterTo) return null;
+
+  const links = [
+    publish.newsletterHtml ? { label: 'Abrir newsletter HTML', href: normalizeDashboardPath(publish.newsletterHtml) } : null,
+    publish.newsletterResult ? { label: 'Abrir resultado de envio', href: normalizeDashboardPath(publish.newsletterResult) } : null,
+  ].filter(Boolean);
+
+  return {
+    name: 'Newsletter',
+    status: publish.newsletterStatus || 'pending',
+    summary: [
+      publish.newsletterSubject ? `Assunto: ${publish.newsletterSubject}.` : 'Edição complementar pronta.',
+      publish.newsletterTo ? `Destino de teste: ${publish.newsletterTo}.` : null,
+      publish.newsletterNotes || null,
+    ].filter(Boolean).join(' '),
+    links,
+  };
+}
+
+function buildChannel(name, href, identifier, status, summary) {
+  if (!href && !identifier) return null;
+  return {
+    name,
+    status: status || 'unknown',
+    summary: [summary, identifier ? `ID: ${identifier}` : null].filter(Boolean).join(' '),
+    links: href ? [{ label: `Abrir ${name}`, href }] : [],
+  };
+}
+
+function buildArtifacts(runDir, runFiles) {
+  return [
+    { label: 'run-folder', path: runDir, href: './', kind: 'folder' },
+    ...Object.values(runFiles)
+      .filter(Boolean)
+      .map((file) => ({
+        label: file.relativePath,
+        path: file.path,
+        href: toRelativeHref(runDir, file.path),
+        kind: inferArtifactKind(file.path),
+      })),
+  ];
+}
+
+async function buildVisualPreviews(runDir, publish, contentPackageFile) {
+  const previews = [];
+  const imageDirCandidates = [join(runDir, 'images'), join(runDir, 'v1', 'images')];
+  const thumbDirCandidates = [join(runDir, 'thumbs'), join(runDir, 'v1', 'thumbs')];
+  const contentPackage = parseContentPackagePreviewData(contentPackageFile?.content || '');
+  const imageDir = imageDirCandidates.find((candidate) => existsSync(candidate));
+  const thumbDir = thumbDirCandidates.find((candidate) => existsSync(candidate)) || join(runDir, 'thumbs');
+
+  if (imageDir && existsSync(imageDir)) {
+    const entries = await readdir(imageDir, { withFileTypes: true });
+    const slideImages = entries
+      .filter((entry) => entry.isFile() && /^slide-\d+\.(jpg|png)$/i.test(entry.name))
+      .map((entry) => entry.name)
+      .sort((left, right) => left.localeCompare(right, undefined, { numeric: true }));
+
+    for (const fileName of slideImages) {
+      const baseName = fileName.replace(/\.(jpg|png)$/i, '');
+      const slideNumber = Number(baseName.match(/slide-(\d+)/i)?.[1] || '0');
+      const htmlPath = join(imageDir, `${baseName}.html`);
+      const imagePath = join(imageDir, fileName);
+      const title = contentPackage.slideTitles.get(slideNumber)
+        || await extractSlideHeadline(htmlPath)
+        || baseName.replace('slide-', 'Slide ');
+      const cta = contentPackage.globalCta
+        || (slideImages.length === slideNumber ? 'Revise a mensagem final e publique com segurança.' : 'Abra o slide e revise o copy antes de publicar.');
+
+      previews.push({
+        label: baseName.replace('slide-', 'Slide '),
+        type: 'slide',
+        title,
+        cta,
+        src: toRelativeHref(runDir, imagePath),
+        href: existsSync(htmlPath) ? toRelativeHref(runDir, htmlPath) : toRelativeHref(runDir, imagePath),
+        meta: existsSync(htmlPath) ? 'Abrir HTML editável' : 'Abrir imagem final',
+      });
+    }
+  }
+
+  const thumbnailCandidates = [
+    publish.youtubeThumbnail ? join(runDir, normalizeDashboardPath(publish.youtubeThumbnail)) : null,
+    join(thumbDir, 'youtube-thumb-16x9.jpg'),
+  ].filter(Boolean);
+
+  const thumbnailPath = thumbnailCandidates.find((candidate) => existsSync(candidate));
+  if (thumbnailPath) {
+    previews.push({
+      label: 'YouTube Thumbnail',
+      type: 'thumbnail',
+      title: 'Thumbnail do vídeo publicado',
+      cta: publish.youtubeUrl ? 'Abra o vídeo final no YouTube.' : 'Revise a thumbnail antes de publicar.',
+      src: toRelativeHref(runDir, thumbnailPath),
+      href: publish.youtubeUrl || toRelativeHref(runDir, thumbnailPath),
+      meta: publish.youtubeUrl ? 'Abrir vídeo publicado' : 'Abrir thumbnail',
+    });
+  }
+
+  return previews;
+}
+
+function parseContentPackagePreviewData(content) {
+  const slideTitles = new Map();
+  const sectionMatches = content.matchAll(/##\s+Slide\s+(\d+)\s+-[^\n]*([\s\S]*?)(?=\n##\s+Slide\s+\d+\s+-|\n##\s+Legenda|\n##\s+Hashtags|\n##\s+YouTube|\n##\s+Notas|\n##\s+Checklist|$)/gi);
+
+  for (const match of sectionMatches) {
+    const slideNumber = Number(match[1]);
+    const titleMatch = match[2]?.match(/\*\*T[íi]tulo:\*\*\s*(.+)/i);
+    const title = sanitizeValue(titleMatch?.[1]?.split(/\r?\n/)[0] || '');
+    if (slideNumber && title) slideTitles.set(slideNumber, title);
+  }
+
+  return {
+    slideTitles,
+    globalCta: extractLabeledValue(content, 'CTA principal'),
+  };
+}
+
+async function extractSlideHeadline(htmlPath) {
+  if (!existsSync(htmlPath)) return null;
+
+  try {
+    const html = await readFile(htmlPath, 'utf-8');
+    const match = html.match(/<h1[^>]*>([\s\S]*?)<\/h1>/i);
+    if (!match) return null;
+    const plainText = match[1]
+      .replace(/<[^>]+>/g, ' ')
+      .replace(/\s+/g, ' ')
+      .trim();
+    return plainText || null;
+  } catch {
+    return null;
+  }
+}
+
+function inferArtifactKind(filePath) {
+  const extension = extname(filePath).toLowerCase();
+  if (extension === '.md') return 'markdown';
+  if (extension === '.json') return 'json';
+  if (extension === '.html') return 'html';
+  if (extension === '.jpg' || extension === '.jpeg' || extension === '.png' || extension === '.webp') return 'image';
+  return 'file';
+}
+
+function normalizeDashboardPath(value) {
+  return String(value).replace(/^output[\\/]/i, '').replace(/[\\/]+/g, '/');
+}
+
+function toRelativeHref(runDir, absolutePath) {
+  const relativePath = relative(runDir, absolutePath).replace(/\\/g, '/');
+  if (!relativePath || relativePath === '.') return './';
+  return relativePath;
+}
+
+function buildErrorList({ publish, state, images, review }) {
+  const items = [];
+
+  if (publish.error) {
+    items.push({ title: 'Erro remanescente de publicação', status: 'warning', message: publish.error });
+  }
+
+  if ((publish.newsletterStatus || '').toLowerCase() === 'failed') {
+    items.push({ title: 'Falha na distribuição complementar', status: 'error', message: publish.newsletterNotes || 'A newsletter complementar falhou.' });
+  }
+
+  const blockingIssues = extractNumberedSection(images?.content || '', 'Blocking Issues');
+  for (const issue of blockingIssues) {
+    if (/nenhum/i.test(issue)) continue;
+    items.push({ title: 'Blocking issue — imagens', status: 'warning', message: issue });
+  }
+
+  const reviewIssues = extractNumberedSection(review?.content || '', 'Blocking Issues');
+  for (const issue of reviewIssues) {
+    if (/nenhum/i.test(issue)) continue;
+    items.push({ title: 'Blocking issue — review', status: 'warning', message: issue });
+  }
+
+  if ((state.status || '').toLowerCase() === 'failed') {
+    items.push({ title: 'Pipeline falhou', status: 'error', message: `Falha registrada em ${state.failedAt || state.updatedAt || 'momento desconhecido'}.` });
+  }
+
+  return items;
+}
+
+function extractNumberedSection(content, heading) {
+  if (!content) return [];
+  const escapedHeading = heading.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const match = content.match(new RegExp(`##\\s+${escapedHeading}([\\s\\S]*?)(?:\\n##\\s+|$)`, 'i'));
+  if (!match) return [];
+  return match[1]
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => /^\d+\.\s+/.test(line))
+    .map((line) => line.replace(/^\d+\.\s+/, '').trim());
+}
+
+async function collectMetrics({ publish, envVars, channelConfig }) {
+  const groups = [];
+  const instagramGroup = await collectInstagramMetrics(publish, envVars, channelConfig);
+  if (instagramGroup) groups.push(instagramGroup);
+
+  const facebookGroup = await collectFacebookMetrics(publish, envVars, channelConfig);
+  if (facebookGroup) groups.push(facebookGroup);
+
+  const youtubeGroup = await collectYouTubeMetrics(publish, envVars, channelConfig);
+  if (youtubeGroup) groups.push(youtubeGroup);
+
+  return groups;
+}
+
+async function collectInstagramMetrics(publish, envVars, channelConfig) {
+  if (!publish.instagramPostId) return null;
+
+  const instagramAliases = channelConfig?.publishing?.instagram?.env_aliases || {};
+  const resolved = resolveInstagramEnv(envVars, {
+    instagramAccessTokenEnv: instagramAliases.access_token || null,
+    instagramUserIdEnv: instagramAliases.user_id || null,
+    facebookPageIdEnv: channelConfig?.publishing?.facebook?.env_aliases?.page_id || null,
+    facebookPageAccessTokenEnv: channelConfig?.publishing?.facebook?.env_aliases?.page_access_token || null,
+  });
+
+  if (!resolved.instagramAccessToken) {
+    return {
+      label: 'Instagram',
+      description: 'Snapshot disponível sem coleta online porque o access token não foi encontrado.',
+      status: 'warning',
+      values: [
+        { label: 'Post ID', value: publish.instagramPostId, unit: 'snapshot' },
+        { label: 'Likes', value: 'N/A', unit: 'api unavailable' },
+      ],
+    };
+  }
+
+  const media = await fetchJson(`https://graph.facebook.com/v22.0/${encodeURIComponent(publish.instagramPostId)}?fields=like_count&access_token=${encodeURIComponent(resolved.instagramAccessToken)}`);
+  const metricsToTry = [
+    { metric: 'views', label: 'Views' },
+    { metric: 'video_views', label: 'Views' },
+    { metric: 'plays', label: 'Plays' },
+    { metric: 'impressions', label: 'Impressions' },
+  ];
+
+  let primaryMetric = { label: 'Views', value: 'N/A', unit: 'snapshot' };
+  for (const metric of metricsToTry) {
+    const insight = await fetchJson(`https://graph.facebook.com/v22.0/${encodeURIComponent(publish.instagramPostId)}/insights?metric=${metric.metric}&access_token=${encodeURIComponent(resolved.instagramAccessToken)}`);
+    const value = insight?.data?.[0]?.values?.[0]?.value;
+    if (value != null) {
+      primaryMetric = { label: metric.label, value, unit: 'api snapshot' };
+      break;
+    }
+  }
+
+  return {
+    label: 'Instagram',
+    description: 'Métricas coletadas via Instagram Graph API.',
+    status: 'published',
+    values: [
+      { label: 'Post ID', value: publish.instagramPostId, unit: 'snapshot' },
+      { label: 'Likes', value: media?.like_count ?? 'N/A', unit: 'api snapshot' },
+      primaryMetric,
+      { label: 'Link', value: publish.instagramUrl ? 'ready' : 'N/A', unit: publish.instagramUrl || 'missing' },
+    ],
+  };
+}
+
+async function collectFacebookMetrics(publish, envVars, channelConfig) {
+  if (!publish.facebookPostId) return null;
+
+  const facebookAliases = channelConfig?.publishing?.facebook?.env_aliases || {};
+  const instagramAliases = channelConfig?.publishing?.instagram?.env_aliases || {};
+  const pageId = facebookAliases.page_id ? envVars[facebookAliases.page_id] : envVars.FACEBOOK_PAGE_ID;
+  const configuredToken = facebookAliases.page_access_token ? envVars[facebookAliases.page_access_token] : envVars.FACEBOOK_PAGE_ACCESS_TOKEN;
+  const fallbackUserToken = instagramAliases.access_token ? envVars[instagramAliases.access_token] : envVars.INSTAGRAM_ACCESS_TOKEN;
+
+  const tokenResolution = pageId
+    ? await resolveFacebookPageAccessToken({ pageId, configuredToken, fallbackUserToken })
+    : null;
+
+  if (!tokenResolution?.token) {
+    return {
+      label: 'Facebook',
+      description: 'Post ID disponível, mas não foi possível resolver um token de Página para métricas online.',
+      status: 'warning',
+      values: [
+        { label: 'Post ID', value: publish.facebookPostId, unit: 'snapshot' },
+        { label: 'Reactions', value: 'N/A', unit: 'api unavailable' },
+      ],
+    };
+  }
+
+  const post = await fetchJson(`https://graph.facebook.com/v22.0/${encodeURIComponent(publish.facebookPostId)}?fields=permalink_url,reactions.summary(total_count).limit(0),comments.summary(total_count).limit(0),shares&access_token=${encodeURIComponent(tokenResolution.token)}`);
+
+  return {
+    label: 'Facebook',
+    description: `Snapshot da Página via ${tokenResolution.source || 'page token'}.`,
+    status: publish.facebookUrl ? 'published' : 'partial',
+    values: [
+      { label: 'Post ID', value: publish.facebookPostId, unit: 'snapshot' },
+      { label: 'Reactions', value: post?.reactions?.summary?.total_count ?? 'N/A', unit: 'api snapshot' },
+      { label: 'Comments', value: post?.comments?.summary?.total_count ?? 'N/A', unit: 'api snapshot' },
+      { label: 'Shares', value: post?.shares?.count ?? 'N/A', unit: 'api snapshot' },
+    ],
+  };
+}
+
+async function collectYouTubeMetrics(publish, envVars, channelConfig) {
+  if (!publish.youtubeVideoId) return null;
+
+  const aliases = channelConfig?.publishing?.youtube?.env_aliases || {};
+  const resolved = resolveYouTubeEnv(envVars, {
+    youtubeClientIdEnv: aliases.client_id || null,
+    youtubeClientSecretEnv: aliases.client_secret || null,
+    youtubeRefreshTokenEnv: aliases.refresh_token || null,
+    youtubeChannelIdEnv: aliases.channel_id || null,
+  });
+
+  if (!resolved.youtubeClientId || !resolved.youtubeClientSecret || !resolved.youtubeRefreshToken) {
+    return {
+      label: 'YouTube',
+      description: 'Vídeo publicado, mas as credenciais OAuth não estão disponíveis para coletar estatísticas.',
+      status: 'warning',
+      values: [
+        { label: 'Video ID', value: publish.youtubeVideoId, unit: 'snapshot' },
+        { label: 'Views', value: 'N/A', unit: 'api unavailable' },
+      ],
+    };
+  }
+
+  const accessToken = await exchangeRefreshToken({
+    clientId: resolved.youtubeClientId,
+    clientSecret: resolved.youtubeClientSecret,
+    refreshToken: resolved.youtubeRefreshToken,
+  });
+
+  const video = await fetchJson(`https://www.googleapis.com/youtube/v3/videos?part=statistics,snippet&id=${encodeURIComponent(publish.youtubeVideoId)}`, {
+    headers: { Authorization: `Bearer ${accessToken}` },
+  });
+
+  const stats = video?.items?.[0]?.statistics || {};
+  const snippet = video?.items?.[0]?.snippet || {};
+
+  return {
+    label: 'YouTube',
+    description: 'Estatísticas coletadas via YouTube Data API.',
+    status: 'published',
+    values: [
+      { label: 'Video ID', value: publish.youtubeVideoId, unit: 'snapshot' },
+      { label: 'Views', value: stats.viewCount ?? 'N/A', unit: 'api snapshot' },
+      { label: 'Likes', value: stats.likeCount ?? 'N/A', unit: 'api snapshot' },
+      { label: 'Comments', value: stats.commentCount ?? 'N/A', unit: 'api snapshot' },
+      { label: 'Published', value: snippet.publishedAt ?? publish.publishedAt ?? 'N/A', unit: 'timestamp' },
+    ],
+  };
+}
+
+function buildMetricsNote(metrics, runContext) {
+  if (!metrics.length) {
+    const legacyNote = runContext.isLegacyOutputRoot ? ' Esta run foi consolidada a partir de uma pasta de output legada.' : '';
+    return `Nenhuma métrica online pôde ser coletada automaticamente. O dashboard ainda preserva os IDs, URLs e o snapshot operacional da run.${legacyNote} Para refresh real, sirva esta pasta com o servidor local do dashboard.`;
+  }
+  return 'O botão Refresh Data tenta primeiro regenerar o snapshot através do servidor local do dashboard. Se esse endpoint não existir, ele apenas relê o JSON atual do mesmo diretório.';
+}
+
+async function fetchJson(url, options = {}) {
+  try {
+    const response = await fetch(url, options);
+    const data = await response.json();
+    if (!response.ok || data?.error) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+async function loadChannelConfig(workspaceRoot, squadName) {
+  const configPath = join(workspaceRoot, 'squads', squadName, 'pipeline', 'data', 'channel-config.yaml');
+  if (!existsSync(configPath)) return null;
+  const content = await readFile(configPath, 'utf-8');
+  return parseChannelConfig(content);
+}
+
+function parseChannelConfig(content) {
+  return {
+    publishing: {
+      instagram: {
+        env_aliases: {
+          access_token: matchIndentedValue(content, ['publishing', 'instagram', 'env_aliases'], 'access_token'),
+          user_id: matchIndentedValue(content, ['publishing', 'instagram', 'env_aliases'], 'user_id'),
+        },
+      },
+      facebook: {
+        env_aliases: {
+          page_id: matchIndentedValue(content, ['publishing', 'facebook', 'env_aliases'], 'page_id'),
+          page_access_token: matchIndentedValue(content, ['publishing', 'facebook', 'env_aliases'], 'page_access_token'),
+        },
+      },
+      youtube: {
+        env_aliases: {
+          client_id: matchIndentedValue(content, ['publishing', 'youtube', 'env_aliases'], 'client_id'),
+          client_secret: matchIndentedValue(content, ['publishing', 'youtube', 'env_aliases'], 'client_secret'),
+          refresh_token: matchIndentedValue(content, ['publishing', 'youtube', 'env_aliases'], 'refresh_token'),
+          channel_id: matchIndentedValue(content, ['publishing', 'youtube', 'env_aliases'], 'channel_id'),
+        },
+      },
+    },
+    dashboard: {
+      static_publish: {
+        enabled: matchIndentedValue(content, ['dashboard', 'static_publish'], 'enabled'),
+        transport: matchIndentedValue(content, ['dashboard', 'static_publish'], 'transport'),
+        public_base_url: matchIndentedValue(content, ['dashboard', 'static_publish'], 'public_base_url'),
+        publish_dir_env: matchIndentedValue(content, ['dashboard', 'static_publish'], 'publish_dir_env'),
+        latest_file_name: matchIndentedValue(content, ['dashboard', 'static_publish'], 'latest_file_name'),
+        ftp: {
+          host_env: matchIndentedValue(content, ['dashboard', 'static_publish', 'ftp'], 'host_env'),
+          port_env: matchIndentedValue(content, ['dashboard', 'static_publish', 'ftp'], 'port_env'),
+          user_env: matchIndentedValue(content, ['dashboard', 'static_publish', 'ftp'], 'user_env'),
+          pass_env: matchIndentedValue(content, ['dashboard', 'static_publish', 'ftp'], 'pass_env'),
+        },
+      },
+    },
+  };
+}
+
+function matchIndentedValue(content, pathSegments, key) {
+  const block = extractIndentedBlock(content, pathSegments);
+  if (!block) return null;
+  const match = block.match(new RegExp(`^\\s*${key}:\\s*([^\\r\\n]+)`, 'm'));
+  return match ? match[1].trim().replace(/^['"]|['"]$/g, '') : null;
+}
+
+function extractIndentedBlock(content, pathSegments) {
+  const lines = content.split(/\r?\n/);
+  let searchFrom = 0;
+  let currentIndent = -1;
+
+  for (const segment of pathSegments) {
+    let found = false;
+    for (let index = searchFrom; index < lines.length; index += 1) {
+      const line = lines[index];
+      const match = line.match(/^(\s*)([^:#]+):/);
+      if (!match) continue;
+      const indent = match[1].length;
+      const key = match[2].trim();
+      if (indent <= currentIndent) continue;
+      if (key === segment) {
+        currentIndent = indent;
+        searchFrom = index + 1;
+        found = true;
+        break;
+      }
+    }
+    if (!found) return null;
+  }
+
+  const blockLines = [];
+  for (let index = searchFrom; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (!line.trim()) {
+      blockLines.push(line);
+      continue;
+    }
+    const indent = line.match(/^(\s*)/)?.[1].length ?? 0;
+    if (indent <= currentIndent) break;
+    blockLines.push(line.slice(currentIndent + 2));
+  }
+
+  return blockLines.join('\n');
+}
+
+async function loadEnvVars(workspaceRoot) {
+  const envVars = { ...process.env };
+  const envPath = join(workspaceRoot, '.env');
+
+  if (!existsSync(envPath)) return envVars;
+
+  const raw = await readFile(envPath, 'utf-8');
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const separatorIndex = trimmed.indexOf('=');
+    if (separatorIndex === -1) continue;
+    const key = trimmed.slice(0, separatorIndex).trim();
+    const value = trimmed.slice(separatorIndex + 1).trim().replace(/^['"]|['"]$/g, '');
+    if (key && !(key in envVars)) envVars[key] = value;
+  }
+
+  return envVars;
+}
+
+function escapeScriptJson(value) {
+  return value.replace(/<\//g, '<\\/');
+}
+
+async function rewritePayloadForStaticPublish({ payload, runDir, publishDir, variantName }) {
+  const publishedPayload = JSON.parse(JSON.stringify(payload || {}));
+
+  if (Array.isArray(publishedPayload.artifacts)) {
+    for (const artifact of publishedPayload.artifacts) {
+      if (artifact.kind === 'folder' || artifact.href === './') {
+        artifact.href = null;
+        artifact.path = `assets/${variantName}/`;
+        continue;
+      }
+
+      const publishedRef = await copyLocalRunReference({
+        runDir,
+        publishDir,
+        variantName,
+        href: artifact.href,
+        absolutePath: artifact.path,
+      });
+
+      if (publishedRef) {
+        artifact.href = publishedRef.href;
+        artifact.path = publishedRef.href;
+      }
+    }
+  }
+
+  if (Array.isArray(publishedPayload.previews)) {
+    for (const preview of publishedPayload.previews) {
+      const publishedSrc = await copyLocalRunReference({
+        runDir,
+        publishDir,
+        variantName,
+        href: preview.src,
+      });
+      if (publishedSrc) preview.src = publishedSrc.href;
+
+      const publishedHref = await copyLocalRunReference({
+        runDir,
+        publishDir,
+        variantName,
+        href: preview.href,
+      });
+      if (publishedHref) preview.href = publishedHref.href;
+    }
+  }
+
+  if (Array.isArray(publishedPayload.channels)) {
+    for (const channel of publishedPayload.channels) {
+      if (!Array.isArray(channel.links)) continue;
+      for (const link of channel.links) {
+        const publishedLink = await copyLocalRunReference({
+          runDir,
+          publishDir,
+          variantName,
+          href: link.href,
+        });
+        if (publishedLink) link.href = publishedLink.href;
+      }
+    }
+  }
+
+  return publishedPayload;
+}
+
+async function copyLocalRunReference({ runDir, publishDir, variantName, href, absolutePath }) {
+  if (!href || isExternalReference(href)) return null;
+
+  const sourcePath = resolveLocalRunReference({ runDir, href, absolutePath });
+  if (!sourcePath || !existsSync(sourcePath)) return null;
+
+  const relativeSourcePath = relative(runDir, sourcePath).replace(/\\/g, '/');
+  if (!relativeSourcePath || relativeSourcePath.startsWith('..')) return null;
+
+  const targetPath = join(publishDir, 'assets', variantName, ...relativeSourcePath.split('/'));
+  await mkdir(dirname(targetPath), { recursive: true });
+  await copyFile(sourcePath, targetPath);
+
+  return {
+    href: `./assets/${variantName}/${relativeSourcePath}`,
+    sourcePath,
+    targetPath,
+  };
+}
+
+function resolveLocalRunReference({ runDir, href, absolutePath }) {
+  if (absolutePath && typeof absolutePath === 'string' && existsSync(absolutePath)) {
+    return absolutePath;
+  }
+
+  if (!href || href === './' || isExternalReference(href)) return null;
+  return resolve(runDir, href);
+}
+
+function isExternalReference(value) {
+  return /^(?:[a-z]+:)?\/\//i.test(String(value || '')) || /^(mailto:|tel:)/i.test(String(value || ''));
+}
+
+function normalizePublicBaseUrl(value) {
+  const normalized = String(value || '').trim();
+  if (!normalized) return '';
+  return normalized.endsWith('/') ? normalized : `${normalized}/`;
+}
+
+function sanitizeFileName(value) {
+  return String(value || 'index.html').replace(/[\\/:*?"<>|]+/g, '-');
+}
+
+const isMain = process.argv[1] === fileURLToPath(import.meta.url);
+if (isMain) {
+  main().catch((error) => {
+    console.error(`❌ ${error.message}`);
+    process.exit(1);
+  });
+}