thumbgate 1.15.0 → 1.16.1

package/scripts/analytics-report.js

@@ -1,328 +0,0 @@
-'use strict';
-
-const https = require('https');
-const { PRODUCTHUNT_URL } = require('./distribution-surfaces');
-const { getOperationalBillingSummary } = require('./operational-summary');
-const { summarizeCreatorPerformance } = require('./creator-campaigns');
-const { getFeedbackPaths } = require('./feedback-loop');
-const { buildPredictiveInsights } = require('./predictive-insights');
-const { getTelemetryAnalytics } = require('./telemetry-analytics');
-
-const NPM_PACKAGE = 'thumbgate';
-const GITHUB_REPO = 'IgorGanapolsky/ThumbGate';
-const PLAUSIBLE_URL = 'https://plausible.io/thumbgate-production.up.railway.app';
-const LANDING_PAGE = 'https://thumbgate-production.up.railway.app';
-
-function httpsGet(url) {
-  return new Promise((resolve, reject) => {
-    https.get(url, { headers: { 'User-Agent': 'thumbgate-analytics' } }, (res) => {
-      let data = '';
-      res.on('data', (chunk) => { data += chunk; });
-      res.on('end', () => {
-        if (res.statusCode >= 400) {
-          reject(new Error(`HTTP ${res.statusCode} for ${url}: ${data}`));
-          return;
-        }
-        try { resolve(JSON.parse(data)); } catch (e) { reject(e); }
-      });
-    }).on('error', reject);
-  });
-}
-
-function sparkline(values) {
-  const chars = '▁▂▃▄▅▆▇█';
-  const max = Math.max(...values, 1);
-  return values.map((v) => chars[Math.min(Math.floor((v / max) * (chars.length - 1)), chars.length - 1)]).join('');
-}
-
-async function fetchNpmMonthly() {
-  return httpsGet(`https://api.npmjs.org/downloads/range/last-month/${NPM_PACKAGE}`);
-}
-
-async function fetchNpmWeekly() {
-  return httpsGet(`https://api.npmjs.org/downloads/point/last-week/${NPM_PACKAGE}`);
-}
-
-async function fetchGitHub() {
-  return httpsGet(`https://api.github.com/repos/${GITHUB_REPO}`);
-}
-
-async function fetchNpmVersions() {
-  return httpsGet(`https://registry.npmjs.org/${NPM_PACKAGE}`);
-}
-
-function loadTelemetrySnapshot() {
-  const { FEEDBACK_DIR } = getFeedbackPaths();
-  return getTelemetryAnalytics(FEEDBACK_DIR);
-}
-
-function getCounterValue(counter = {}, key) {
-  return Number(counter && counter[key]) || 0;
-}
-
-function mergeDimensionCounters(metricCounters = {}) {
-  const metrics = Object.keys(metricCounters);
-  const rows = new Map();
-
-  for (const metric of metrics) {
-    const counter = metricCounters[metric] || {};
-    for (const [rawKey, rawValue] of Object.entries(counter)) {
-      const key = String(rawKey || '').trim() || 'unknown';
-      const row = rows.get(key) || { key };
-      row[metric] = Number(rawValue || 0);
-      rows.set(key, row);
-    }
-  }
-
-  return Array.from(rows.values());
-}
-
-function buildPredictiveStagingModel(telemetry = {}, billingSummary = {}) {
-  return {
-    dims: {
-      sources: mergeDimensionCounters({
-        pageViews: telemetry.visitors && telemetry.visitors.bySource,
-        checkoutStarts: telemetry.ctas && telemetry.ctas.checkoutStartsBySource,
-        acquisitionLeads: billingSummary.attribution && billingSummary.attribution.acquisitionBySource,
-        paidCustomers: billingSummary.attribution && billingSummary.attribution.paidBySource,
-        bookedRevenueCents: billingSummary.attribution && billingSummary.attribution.bookedRevenueBySourceCents,
-      }),
-      creators: mergeDimensionCounters({
-        pageViews: telemetry.visitors && telemetry.visitors.byCreator,
-        checkoutStarts: telemetry.ctas && telemetry.ctas.checkoutStartsByCreator,
-        acquisitionLeads: billingSummary.attribution && billingSummary.attribution.acquisitionByCreator,
-        paidCustomers: billingSummary.attribution && billingSummary.attribution.paidByCreator,
-        bookedRevenueCents: billingSummary.attribution && billingSummary.attribution.bookedRevenueByCreatorCents,
-        workflowSprintLeads: billingSummary.pipeline && billingSummary.pipeline.workflowSprintLeads && billingSummary.pipeline.workflowSprintLeads.byCreator,
-        qualifiedWorkflowSprintLeads: billingSummary.pipeline && billingSummary.pipeline.qualifiedWorkflowSprintLeads && billingSummary.pipeline.qualifiedWorkflowSprintLeads.byCreator,
-      }),
-    },
-  };
-}
-
-function resolveProductHuntCount(primaryCounter = {}, secondaryCounter = {}) {
-  const primary = getCounterValue(primaryCounter, 'producthunt');
-  if (primary > 0) return primary;
-  return getCounterValue(secondaryCounter, 'producthunt');
-}
-
-async function collectAnalytics(fetchers = {}) {
-  const fetchMonthly = fetchers.fetchNpmMonthly || fetchNpmMonthly;
-  const fetchWeekly = fetchers.fetchNpmWeekly || fetchNpmWeekly;
-  const fetchRepo = fetchers.fetchGitHub || fetchGitHub;
-  const fetchVersions = fetchers.fetchNpmVersions || fetchNpmVersions;
-  const fetchTelemetry = fetchers.fetchTelemetry || loadTelemetrySnapshot;
-  const fetchBillingSummary = fetchers.fetchBillingSummary || (async () => {
-    const result = await getOperationalBillingSummary();
-    return result.summary;
-  });
-
-  const [monthly, weekly, github, npmMeta, telemetry, billingSummary] = await Promise.all([
-    fetchMonthly(),
-    fetchWeekly(),
-    fetchRepo(),
-    fetchVersions().catch(() => null),
-    Promise.resolve().then(() => fetchTelemetry()).catch(() => null),
-    Promise.resolve().then(() => fetchBillingSummary()).catch(() => null),
-  ]);
-
-  return { monthly, weekly, github, npmMeta, telemetry, billingSummary };
-}
-
-/**
- * Estimate organic downloads by filtering out publish-day inflation.
- * npm registry mirrors, bot crawlers (socket.dev, snyk, bundlephobia),
- * and npm-stat bots all re-download on publish events.
- * Weekend days with no publishes give the organic baseline.
- */
-function estimateOrganicDownloads(dailyDownloads, publishDates) {
-  const publishSet = new Set(publishDates);
-
-  let weekendNoPublishTotal = 0;
-  let weekendNoPublishCount = 0;
-  let publishDayTotal = 0;
-  let publishDayCount = 0;
-  let noPublishDayTotal = 0;
-  let noPublishDayCount = 0;
-
-  for (const day of dailyDownloads) {
-    const dt = new Date(day.day + 'T00:00:00Z');
-    const isWeekend = dt.getUTCDay() === 0 || dt.getUTCDay() === 6;
-    const isPublishDay = publishSet.has(day.day);
-
-    if (isPublishDay) {
-      publishDayTotal += day.downloads;
-      publishDayCount++;
-    } else {
-      noPublishDayTotal += day.downloads;
-      noPublishDayCount++;
-      if (isWeekend) {
-        weekendNoPublishTotal += day.downloads;
-        weekendNoPublishCount++;
-      }
-    }
-  }
-
-  const organicDailyBaseline = weekendNoPublishCount > 0
-    ? Math.round(weekendNoPublishTotal / weekendNoPublishCount)
-    : (noPublishDayCount > 0 ? Math.round(noPublishDayTotal / noPublishDayCount) : 0);
-
-  const totalDownloads = dailyDownloads.reduce((s, d) => s + d.downloads, 0);
-  const estimatedOrganic30d = organicDailyBaseline * 30;
-  const estimatedInflated = totalDownloads - estimatedOrganic30d;
-  const organicRate = totalDownloads > 0 ? (estimatedOrganic30d / totalDownloads * 100) : 0;
-
-  return {
-    organicDailyBaseline,
-    estimatedOrganic30d,
-    estimatedInflated: Math.max(0, estimatedInflated),
-    organicRate: Math.min(100, organicRate),
-    organicWeekly: organicDailyBaseline * 7,
-    publishDayAvg: publishDayCount > 0 ? Math.round(publishDayTotal / publishDayCount) : 0,
-    noPublishDayAvg: noPublishDayCount > 0 ? Math.round(noPublishDayTotal / noPublishDayCount) : 0,
-    publishDayCount,
-    totalDownloads,
-  };
-}
-
-function formatCreatorRows(telemetry = null, billingSummary = null) {
-  return summarizeCreatorPerformance(telemetry, billingSummary).map((entry, index) => {
-    const revenueDollars = (entry.bookedRevenueCents / 100).toFixed(2);
-    return `   ${index + 1}. ${entry.creator} — rev $${revenueDollars}, paid ${entry.paidOrders}, sprint ${entry.qualifiedSprintLeads}/${entry.sprintLeads}, checkouts ${entry.checkoutStarts}, visitors ${entry.visitors}`;
-  });
-}
-
-function formatReport(monthly, weekly, github, npmMeta, telemetry = null, billingSummary = null) {
-  const weeklyDownloads = weekly.downloads || 0;
-  const allDays = monthly.downloads || [];
-  const monthlyDownloads = allDays.reduce((sum, d) => sum + d.downloads, 0);
-  const dailyValues = allDays.slice(-7).map((d) => d.downloads);
-  const trend = sparkline(dailyValues);
-
-  // Extract publish dates from npm registry metadata
-  const publishDates = [];
-  if (npmMeta && npmMeta.time) {
-    for (const [version, timestamp] of Object.entries(npmMeta.time)) {
-      if (version !== 'created' && version !== 'modified') {
-        publishDates.push(timestamp.slice(0, 10));
-      }
-    }
-  }
-
-  const organic = estimateOrganicDownloads(allDays, publishDates);
-  const productHuntVisitors = telemetry
-    ? resolveProductHuntCount(telemetry.visitors.byTrafficChannel, telemetry.visitors.bySource)
-    : 0;
-  const productHuntCtas = telemetry
-    ? resolveProductHuntCount(telemetry.ctas.byTrafficChannel, telemetry.ctas.bySource)
-    : 0;
-  const productHuntCheckouts = telemetry
-    ? resolveProductHuntCount(telemetry.ctas.checkoutStartsByTrafficChannel, telemetry.ctas.checkoutStartsBySource)
-    : 0;
-  const telemetryWindow = telemetry && telemetry.window ? telemetry.window : 'all';
-  const telemetryLastSeen = telemetry && telemetry.latestSeenAt ? telemetry.latestSeenAt : 'none';
-  const creatorRows = formatCreatorRows(telemetry, billingSummary);
-  const predictive = buildPredictiveInsights({
-    telemetryAnalytics: telemetry || {},
-    billingSummary: billingSummary || {},
-    stagingModel: buildPredictiveStagingModel(telemetry || {}, billingSummary || {}),
-  });
-
-  const lines = [
-    '',
-    '╔══════════════════════════════════════════════════════════════════╗',
-    '║          ThumbGate — Unified Analytics Snapshot                  ║',
-    '╚══════════════════════════════════════════════════════════════════╝',
-    '',
-    '📦 npm — thumbgate (REPORTED)',
-    `   Weekly downloads:  ${weeklyDownloads.toLocaleString()}`,
-    `   Monthly downloads: ${monthlyDownloads.toLocaleString()}`,
-    `   Daily trend (7d):  ${trend}  [${dailyValues.join(', ')}]`,
-    '',
-    '🔬 npm — ORGANIC ESTIMATE (excluding publish-day + bot inflation)',
-    `   Organic baseline:  ~${organic.organicDailyBaseline}/day → ~${organic.organicWeekly}/week → ~${organic.estimatedOrganic30d.toLocaleString()}/month`,
-    `   Publish-day avg:   ${organic.publishDayAvg}/day (${organic.publishDayCount} publish days this period)`,
-    `   No-publish avg:    ${organic.noPublishDayAvg}/day`,
-    `   Organic rate:      ${organic.organicRate.toFixed(1)}% of reported downloads`,
-    `   Inflated by:       ~${organic.estimatedInflated.toLocaleString()} downloads (registry mirrors, bots, self-installs)`,
-    '',
-    '⭐ GitHub — IgorGanapolsky/ThumbGate',
-    `   Stars:       ${(github.stargazers_count || 0).toLocaleString()}`,
-    `   Forks:       ${(github.forks_count || 0).toLocaleString()}`,
-    `   Open issues: ${(github.open_issues_count || 0).toLocaleString()}`,
-    `   Watchers:    ${(github.subscribers_count || 0).toLocaleString()}`,
-    '',
-    '🌐 Landing Page',
-    `   Plausible:  ${PLAUSIBLE_URL}`,
-    `   ⚠️  Check Plausible to exclude your own IP (Settings → filter)`,
-    '',
-    '🚀 ProductHunt',
-    `   Listing:    ${PRODUCTHUNT_URL}`,
-    `   Tracked:    utm_source=producthunt → traffic_channel=producthunt`,
-    `   Visitors:   ${productHuntVisitors}`,
-    `   CTA clicks: ${productHuntCtas}`,
-    `   Checkouts:  ${productHuntCheckouts}`,
-    `   Window:     ${telemetryWindow}`,
-    `   Last seen:  ${telemetryLastSeen}`,
-    '',
-    '🎥 Creator Partnerships',
-    '   Ranked: booked revenue → paid orders → qualified sprint leads → checkouts',
-    ...(creatorRows.length > 0 ? creatorRows : ['   No attributed creator campaigns yet.']),
-    '',
-    '🔮 Predictive Insights',
-    `   Pro propensity:   ${predictive.upgradePropensity.pro.band} (${predictive.upgradePropensity.pro.score})`,
-    `   Team propensity:  ${predictive.upgradePropensity.team.band} (${predictive.upgradePropensity.team.score})`,
-    `   Revenue forecast: $${(predictive.revenueForecast.predictedBookedRevenueCents / 100).toFixed(2)} (+$${(predictive.revenueForecast.incrementalOpportunityCents / 100).toFixed(2)} opportunity)`,
-    `   Predictive alerts:${predictive.anomalySummary.count} (${predictive.anomalySummary.severity})`,
-    ...(predictive.topCreators[0]
-      ? [`   Top creator opp: ${predictive.topCreators[0].key} → +$${(predictive.topCreators[0].opportunityRevenueCents / 100).toFixed(2)}`]
-      : ['   Top creator opp: none yet']),
-    ...(predictive.topSources[0]
-      ? [`   Top channel opp: ${predictive.topSources[0].key} → +$${(predictive.topSources[0].opportunityRevenueCents / 100).toFixed(2)}`]
-      : ['   Top channel opp: none yet']),
-    '',
-    '🔗 UTM links for sharing (tracks referral source in Plausible)',
-    `   Twitter:     ${LANDING_PAGE}?utm_source=twitter&utm_medium=social&utm_campaign=launch`,
-    `   LinkedIn:    ${LANDING_PAGE}?utm_source=linkedin&utm_medium=social&utm_campaign=launch`,
-    `   Reddit:      ${LANDING_PAGE}?utm_source=reddit&utm_medium=social&utm_campaign=launch`,
-    `   HackerNews:  ${LANDING_PAGE}?utm_source=hackernews&utm_medium=social&utm_campaign=launch`,
-    '',
-    '📏 HONEST METRICS (use these, not the inflated ones)',
-    `   Real npm traction:  ~${organic.organicWeekly} downloads/week`,
-    `   GitHub stars:       ${(github.stargazers_count || 0)}`,
-    `   ProductHunt:        check listing for upvotes/followers`,
-    `   Landing page:       check Plausible (exclude your IP!)`,
-    '',
-  ];
-
-  return lines.join('\n');
-}
-
-async function run(options = {}) {
-  const log = options.log || console.log;
-  const error = options.error || console.error;
-  const exit = options.exit || process.exit;
-
-  try {
-    const { monthly, weekly, github, npmMeta, telemetry, billingSummary } = await collectAnalytics(options.fetchers);
-    log(formatReport(monthly, weekly, github, npmMeta, telemetry, billingSummary));
-  } catch (err) {
-    error('Analytics fetch failed:', err.message);
-    exit(1);
-  }
-}
-
-module.exports = {
-  run,
-  collectAnalytics,
-  formatReport,
-  fetchNpmMonthly,
-  fetchNpmWeekly,
-  fetchGitHub,
-  fetchNpmVersions,
-  estimateOrganicDownloads,
-};
-
-if (require.main === module) {
-  run();
-}

package/scripts/autonomous-workflow.js

@@ -1,377 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-
-const { ensureDir } = require('./fs-utils');
-const {
-  executeJob,
-  readJobState,
-  resumeJob,
-} = require('./async-job-runner');
-const {
-  createCheckpoint,
-  advanceCheckpoint,
-  loadCheckpoint,
-  saveCheckpoint,
-} = require('./workflow-gate-checkpoint');
-const { appendWorkflowRun } = require('./workflow-runs');
-
-function normalizeText(value) {
-  if (value === undefined || value === null) return '';
-  return String(value).trim();
-}
-
-function slugify(value, fallback = 'workflow') {
-  // Avoid any `-+` quantifier in an edge-anchored regex (Sonar javascript:S5852
-  // still flags even the anchored form). Strip edge dashes with a linear scan.
-  const collapsed = normalizeText(value).toLowerCase().replace(/[^a-z0-9]+/g, '-');
-  let start = 0;
-  let end = collapsed.length;
-  while (start < end && collapsed.charCodeAt(start) === 45) start += 1;
-  while (end > start && collapsed.charCodeAt(end - 1) === 45) end -= 1;
-  const normalized = collapsed.slice(start, end);
-  return normalized || fallback;
-}
-
-function getWorkflowPaths(workflowId, cwd = process.cwd()) {
-  const rootDir = path.join(cwd, '.thumbgate', 'autonomous-workflows', workflowId);
-  return {
-    rootDir,
-    checkpointPath: path.join(rootDir, 'checkpoint.json'),
-    reportJsonPath: path.join(rootDir, 'report.json'),
-    reportMdPath: path.join(rootDir, 'report.md'),
-    planPath: path.join(rootDir, 'plan.json'),
-  };
-}
-
-function normalizePlan(input, workflowId) {
-  if (Array.isArray(input)) {
-    return {
-      workflowId,
-      summary: input.map((step) => normalizeText(step)).filter(Boolean).join(' | ') || 'Execution plan ready',
-      steps: input
-        .map((step, index) => ({
-          id: `step_${index + 1}`,
-          description: normalizeText(step),
-        }))
-        .filter((step) => step.description),
-    };
-  }
-
-  if (input && typeof input === 'object') {
-    const steps = Array.isArray(input.steps)
-      ? input.steps
-        .map((step, index) => {
-          if (typeof step === 'string') {
-            return {
-              id: `step_${index + 1}`,
-              description: normalizeText(step),
-            };
-          }
-
-          if (step && typeof step === 'object') {
-            return {
-              id: normalizeText(step.id) || `step_${index + 1}`,
-              description: normalizeText(step.description || step.summary || step.name),
-            };
-          }
-
-          return null;
-        })
-        .filter(Boolean)
-      : [];
-
-    return {
-      workflowId,
-      summary: normalizeText(input.summary) || steps.map((step) => step.description).join(' | ') || 'Execution plan ready',
-      steps,
-    };
-  }
-
-  const summary = normalizeText(input) || 'Execution plan ready';
-  return {
-    workflowId,
-    summary,
-    steps: summary ? [{ id: 'step_1', description: summary }] : [],
-  };
-}
-
-function buildDefaultPlan(spec, workflowId) {
-  const executionSteps = Array.isArray(spec.stages)
-    ? spec.stages.map((stage, index) => normalizeText(stage && (stage.name || stage.context || stage.command)) || `Stage ${index + 1}`)
-    : [];
-
-  return normalizePlan({
-    summary: normalizeText(spec.planSummary) || `Run ${executionSteps.length || 0} execution stage(s) and verify output`,
-    steps: [
-      { id: 'intent', description: normalizeText(spec.intent) || 'Intent captured' },
-      { id: 'plan', description: 'Execution plan generated' },
-      ...executionSteps.map((description, index) => ({
-        id: `execute_${index + 1}`,
-        description,
-      })),
-      { id: 'verify', description: 'Verification loop completed' },
-      { id: 'report', description: 'Evidence-backed report recorded' },
-    ],
-    workflowId,
-  }, workflowId);
-}
-
-function resolvePlan(spec, workflowId) {
-  if (typeof spec.plan === 'function') {
-    return normalizePlan(spec.plan(spec), workflowId);
-  }
-
-  if (spec.plan) {
-    return normalizePlan(spec.plan, workflowId);
-  }
-
-  return buildDefaultPlan(spec, workflowId);
-}
-
-function buildExecutionJob(spec, workflowId, paths, plan) {
-  return {
-    id: spec.jobId || `${workflowId}-execution`,
-    tags: Array.isArray(spec.tags) ? spec.tags : [],
-    skill: spec.skill || 'autonomous-workflow',
-    partnerProfile: spec.partnerProfile || null,
-    verificationMode: spec.verificationMode === 'none' ? 'none' : 'standard',
-    autoImprove: spec.autoImprove !== false,
-    recordFeedback: spec.recordFeedback !== false,
-    stages: Array.isArray(spec.stages) ? spec.stages : [],
-    metadata: {
-      workflowId,
-      planSummary: plan.summary,
-      workflowRoot: paths.rootDir,
-    },
-  };
-}
-
-function writeWorkflowPlan(paths, plan) {
-  ensureDir(paths.rootDir);
-  fs.writeFileSync(paths.planPath, `${JSON.stringify(plan, null, 2)}\n`, 'utf8');
-  return paths.planPath;
-}
-
-function collectEvidenceArtifacts(paths, executionResult, extraArtifacts = []) {
-  return [
-    paths.checkpointPath,
-    paths.planPath,
-    paths.reportJsonPath,
-    paths.reportMdPath,
-    executionResult && executionResult.jobStatePath ? executionResult.jobStatePath : null,
-    ...extraArtifacts,
-  ].filter(Boolean);
-}
-
-function writeWorkflowReport(paths, report) {
-  ensureDir(paths.rootDir);
-  fs.writeFileSync(paths.reportJsonPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
-
-  const markdown = [
-    `# ${report.workflowName}`,
-    '',
-    `- Workflow ID: ${report.workflowId}`,
-    `- Status: ${report.status}`,
-    `- Intent: ${report.intent}`,
-    `- Verification accepted: ${report.verification ? String(report.verification.accepted) : 'skipped'}`,
-    `- Evidence artifacts: ${report.evidenceArtifacts.length}`,
-    '',
-    '## Plan',
-    '',
-    report.plan.summary,
-    '',
-    ...report.plan.steps.map((step) => `- ${step.id}: ${step.description}`),
-    '',
-    '## Execution',
-    '',
-    ...report.execution.stageHistory.map((stage) => `- ${stage.name} @ ${stage.completedAt}`),
-    '',
-    '## Evidence Artifacts',
-    '',
-    ...report.evidenceArtifacts.map((artifact) => `- ${artifact}`),
-  ].join('\n');
-
-  fs.writeFileSync(paths.reportMdPath, `${markdown}\n`, 'utf8');
-  return {
-    json: paths.reportJsonPath,
-    markdown: paths.reportMdPath,
-  };
-}
-
-function recordAutonomousWorkflowRun(spec, report, evidenceArtifacts, feedbackDir) {
-  const proofBacked = report.status === 'completed'
-    && (!report.verification || report.verification.accepted)
-    && evidenceArtifacts.length > 0;
-
-  return appendWorkflowRun({
-    workflowId: report.workflowId,
-    workflowName: report.workflowName,
-    owner: spec.owner || 'automation',
-    runtime: 'node',
-    status: report.status,
-    customerType: spec.customerType || 'internal_dogfood',
-    teamId: spec.teamId || null,
-    reviewed: proofBacked,
-    reviewedBy: proofBacked ? (spec.reviewedBy || 'automation') : null,
-    proofBacked,
-    proofArtifacts: evidenceArtifacts,
-    source: spec.source || 'autonomous-workflow',
-    metadata: {
-      intent: report.intent,
-      planSummary: report.plan.summary,
-      verificationAttempts: report.verification ? report.verification.attempts : 0,
-      executionJobId: report.execution.jobId,
-    },
-  }, feedbackDir);
-}
-
-function runAutonomousWorkflow(spec = {}, options = {}) {
-  const cwd = options.cwd || process.cwd();
-  const workflowId = normalizeText(spec.workflowId) || slugify(spec.name || spec.intent, 'autonomous-workflow');
-  const workflowName = normalizeText(spec.name) || `Autonomous workflow ${workflowId}`;
-  const intent = normalizeText(spec.intent) || 'Intent not provided';
-  const paths = getWorkflowPaths(workflowId, cwd);
-  const plan = resolvePlan(spec, workflowId);
-
-  writeWorkflowPlan(paths, plan);
-
-  let checkpoint = createCheckpoint({
-    workflowId,
-    phase: 'intent',
-    status: 'running',
-    intent: { summary: intent },
-    plan,
-    evidence: [paths.planPath],
-    metadata: {
-      workflowName,
-    },
-  });
-  saveCheckpoint(checkpoint, paths.checkpointPath);
-
-  checkpoint = advanceCheckpoint(checkpoint, {
-    phase: 'plan',
-    status: 'running',
-    plan,
-    evidence: [paths.planPath],
-  });
-  saveCheckpoint(checkpoint, paths.checkpointPath);
-
-  const job = buildExecutionJob(spec, workflowId, paths, plan);
-  const executionResult = options.resume === true
-    ? resumeJob(job.id, job)
-    : executeJob(job);
-  const jobState = readJobState(job.id);
-
-  checkpoint = advanceCheckpoint(checkpoint, {
-    phase: 'verify',
-    status: executionResult.status,
-    evidence: jobState && jobState.verification ? [paths.checkpointPath] : [],
-    metadata: {
-      executionJobId: job.id,
-      executionStatus: executionResult.status,
-    },
-  });
-  saveCheckpoint(checkpoint, paths.checkpointPath);
-
-  const report = {
-    workflowId,
-    workflowName,
-    status: executionResult.status,
-    intent,
-    plan,
-    execution: {
-      jobId: job.id,
-      status: executionResult.status,
-      stageHistory: Array.isArray(jobState && jobState.stageHistory) ? jobState.stageHistory : [],
-      checkpointCount: Array.isArray(jobState && jobState.checkpoints) ? jobState.checkpoints.length : 0,
-      currentContext: jobState && jobState.currentContext ? jobState.currentContext : '',
-      jobStatePath: jobState ? path.join(getFeedbackDir(options.feedbackDir), 'jobs', job.id, 'state.json') : null,
-    },
-    verification: executionResult.phases ? executionResult.phases.verification : null,
-    phases: executionResult.phases || null,
-    timestamp: new Date().toISOString(),
-    evidenceArtifacts: [],
-  };
-
-  const evidenceArtifacts = collectEvidenceArtifacts(paths, report.execution, spec.proofArtifacts);
-  report.evidenceArtifacts = evidenceArtifacts;
-
-  checkpoint = advanceCheckpoint(checkpoint, {
-    phase: 'report',
-    status: executionResult.status,
-    report: {
-      status: report.status,
-      generatedAt: report.timestamp,
-    },
-    evidence: evidenceArtifacts,
-  });
-  saveCheckpoint(checkpoint, paths.checkpointPath);
-
-  writeWorkflowReport(paths, report);
-  report.workflowRun = recordAutonomousWorkflowRun(spec, report, evidenceArtifacts, options.feedbackDir);
-  fs.writeFileSync(paths.reportJsonPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
-
-  return report;
-}
-
-function getFeedbackDir(feedbackDir) {
-  if (feedbackDir) return feedbackDir;
-  return process.env.THUMBGATE_FEEDBACK_DIR || path.join(process.cwd(), '.thumbgate');
-}
-
-function resumeAutonomousWorkflow(spec = {}, options = {}) {
-  return runAutonomousWorkflow(spec, { ...options, resume: true });
-}
-
-function readWorkflowReport(workflowId, options = {}) {
-  const paths = getWorkflowPaths(workflowId, options.cwd || process.cwd());
-  if (!fs.existsSync(paths.reportJsonPath)) return null;
-  return JSON.parse(fs.readFileSync(paths.reportJsonPath, 'utf8'));
-}
-
-function isCliInvocation(argv = process.argv) {
-  const invokedPath = argv[1];
-  return invokedPath ? path.resolve(invokedPath) === __filename : false;
-}
-
-function parseArgs(argv = process.argv.slice(2)) {
-  const args = {};
-  for (const arg of argv) {
-    if (!arg.startsWith('--')) continue;
-    const [key, ...rest] = arg.slice(2).split('=');
-    args[key] = rest.length > 0 ? rest.join('=') : true;
-  }
-  return args;
-}
-
-if (isCliInvocation()) {
-  const args = parseArgs();
-  if (!args.file) {
-    console.error('Usage: node scripts/autonomous-workflow.js --file=workflow.json [--resume]');
-    process.exit(1);
-  }
-
-  const specPath = path.resolve(args.file);
-  const spec = JSON.parse(fs.readFileSync(specPath, 'utf8'));
-  const report = args.resume ? resumeAutonomousWorkflow(spec) : runAutonomousWorkflow(spec);
-  console.log(JSON.stringify(report, null, 2));
-  process.exit(report.status === 'completed' ? 0 : 1);
-}
-
-module.exports = {
-  buildDefaultPlan,
-  collectEvidenceArtifacts,
-  getWorkflowPaths,
-  normalizePlan,
-  parseArgs,
-  readWorkflowReport,
-  recordAutonomousWorkflowRun,
-  resumeAutonomousWorkflow,
-  runAutonomousWorkflow,
-  slugify,
-  writeWorkflowPlan,
-  writeWorkflowReport,
-};