thumbgate 1.3.0 → 1.4.1

package/scripts/prove-intelligence.js

@@ -13,15 +13,13 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { execSync } = require('child_process');
+const { ensureDir } = require('./fs-utils');
 
 const ROOT = path.join(__dirname, '..');
 function getProofDir() {
   return process.env.THUMBGATE_PROOF_DIR || path.join(ROOT, 'proof');
 }
 
-function ensureDir(d) {
-  if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
-}
 
 // ---------------------------------------------------------------------------
 // Run test suite and parse results

package/scripts/prove-lancedb.js

@@ -17,6 +17,7 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 const { escapeMarkdownTableCell } = require('./markdown-escape');
+const { ensureDir } = require('./fs-utils');
 
 const ROOT = path.join(__dirname, '..');
 const PKG = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf-8'));
@@ -63,11 +64,6 @@ function createInMemoryLanceLoader() {
   });
 }
 
-function ensureDir(dirPath) {
-  if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true });
-  }
-}
 
 function status(condition) {
   return condition ? 'pass' : 'fail';

package/scripts/prove-local-intelligence.js

@@ -5,13 +5,11 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { execSync } = require('child_process');
+const { ensureDir } = require('./fs-utils');
 
 const ROOT = path.join(__dirname, '..');
 const DEFAULT_PROOF_DIR = process.env.THUMBGATE_PROOF_DIR || path.join(ROOT, 'proof');
 
-function ensureDir(dirPath) {
-  if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath, { recursive: true });
-}
 
 function runTests() {
   try {

package/scripts/prove-packaged-runtime.js

@@ -10,6 +10,9 @@ const { execFileSync } = require('child_process');
 
 const ROOT = path.join(__dirname, '..');
 const DEFAULT_TIMEOUT_MS = 15000;
+const DEFAULT_PUBLISH_INSTALL_RETRIES = 6;
+const DEFAULT_PUBLISH_INSTALL_DELAY_MS = 5000;
+const MAX_PUBLISH_INSTALL_DELAY_MS = 30000;
 const STATUSLINE_INPUT = JSON.stringify({ context_window: { used_percentage: 12 } });
 
 function parseArgs(argv = process.argv.slice(2)) {
@@ -55,6 +58,53 @@ function installPackage(prefixDir, packageSpec) {
   return path.join(prefixDir, 'node_modules', '.bin', 'thumbgate');
 }
 
+function isRemotePackageSpec(packageSpec) {
+  if (!packageSpec) return false;
+  return !/^(?:\.{0,2}\/|\/|file:)/.test(packageSpec) && !packageSpec.endsWith('.tgz');
+}
+
+function isTransientRegistryMiss(error) {
+  const text = [
+    error && error.message,
+    error && error.stdout,
+    error && error.stderr,
+  ]
+    .filter(Boolean)
+    .join('\n');
+  return /ETARGET|No matching version found|npm error code E404|404 Not Found/i.test(text);
+}
+
+async function installPackageWithRetry(prefixDir, packageSpec, options = {}) {
+  const installImpl = options.installImpl || installPackage;
+  const sleepImpl = options.sleepImpl || sleep;
+  const remotePackage = options.remotePackage !== undefined ? options.remotePackage : isRemotePackageSpec(packageSpec);
+  const attempts = remotePackage ? Number(options.attempts || DEFAULT_PUBLISH_INSTALL_RETRIES) : 1;
+  let delayMs = Number(options.delayMs || DEFAULT_PUBLISH_INSTALL_DELAY_MS);
+  let lastError = null;
+
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    if (attempt > 1) {
+      fs.rmSync(prefixDir, { recursive: true, force: true });
+    }
+    try {
+      return installImpl(prefixDir, packageSpec);
+    } catch (error) {
+      lastError = error;
+      const retryable = remotePackage && isTransientRegistryMiss(error) && attempt < attempts;
+      if (!retryable) {
+        throw error;
+      }
+      process.stderr.write(
+        `Retrying published package install for ${packageSpec} after transient registry miss (${attempt}/${attempts - 1})\n`
+      );
+      await sleepImpl(delayMs);
+      delayMs = Math.min(Math.round(delayMs * 1.5), MAX_PUBLISH_INSTALL_DELAY_MS);
+    }
+  }
+
+  throw lastError || new Error(`Failed to install package ${packageSpec}`);
+}
+
 function request(url, timeoutMs = 2000) {
   return new Promise((resolve, reject) => {
     const req = http.get(url, (res) => {
@@ -175,7 +225,10 @@ async function runPackagedRuntimeSmoke(options = {}) {
 
   try {
     const packageSpec = options.packageSpec || packCurrentRepo(packDir);
-    const runtimeBin = installPackage(runtimeDir, packageSpec);
+    const runtimeBin = await installPackageWithRetry(runtimeDir, packageSpec, {
+      attempts: options.installAttempts,
+      delayMs: options.installDelayMs,
+    });
     if (!fs.existsSync(runtimeBin)) {
       throw new Error(`Installed runtime binary is missing: ${runtimeBin}`);
     }
@@ -210,17 +263,25 @@ async function runPackagedRuntimeSmoke(options = {}) {
     }
 
     const readyStatusline = renderStatusline(runtimeBin, projectDir, env);
-    if (!readyStatusline.includes(`${origin}/dashboard`)) {
-      throw new Error(`Ready statusline missing dashboard URL: ${readyStatusline.trim()}`);
+    if (!/(Dashboard|Dashboard…)/.test(readyStatusline)) {
+      throw new Error(`Ready statusline missing dashboard label: ${readyStatusline.trim()}`);
+    }
+    if (!/(Lessons|Lessons…)/.test(readyStatusline)) {
+      throw new Error(`Ready statusline missing lessons label: ${readyStatusline.trim()}`);
+    }
+    if (readyStatusline.includes(`${origin}/dashboard`)) {
+      throw new Error(`Ready statusline leaked dashboard URL: ${readyStatusline.trim()}`);
     }
-    if (!readyStatusline.includes(`${origin}/lessons`)) {
-      throw new Error(`Ready statusline missing lessons URL: ${readyStatusline.trim()}`);
+    if (readyStatusline.includes(`${origin}/lessons`)) {
+      throw new Error(`Ready statusline leaked lessons URL: ${readyStatusline.trim()}`);
     }
-    if (!readyStatusline.includes(`${origin}/feedback/quick?signal=up`)) {
-      throw new Error(`Ready statusline missing thumbs-up URL: ${readyStatusline.trim()}`);
+    // Thumbs-up/down icons stay inline while dashboard + lessons remain compact
+    // labels, even after the local API is up.
+    if (!readyStatusline.includes('👍')) {
+      throw new Error(`Ready statusline missing thumbs-up icon: ${readyStatusline.trim()}`);
     }
-    if (!readyStatusline.includes(`${origin}/feedback/quick?signal=down`)) {
-      throw new Error(`Ready statusline missing thumbs-down URL: ${readyStatusline.trim()}`);
+    if (!readyStatusline.includes('👎')) {
+      throw new Error(`Ready statusline missing thumbs-down icon: ${readyStatusline.trim()}`);
     }
 
     return {
@@ -241,6 +302,8 @@ async function main() {
     packageSpec: args.packageSpec,
     expectedVersion: args.expectedVersion,
     timeoutMs: args.timeoutMs,
+    installAttempts: args.installAttempts,
+    installDelayMs: args.installDelayMs,
   });
   process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
 }
@@ -254,6 +317,9 @@ if (require.main === module) {
 
 module.exports = {
   getAvailablePort,
+  installPackageWithRetry,
+  isRemotePackageSpec,
+  isTransientRegistryMiss,
   packCurrentRepo,
   runPackagedRuntimeSmoke,
   waitForHealthy,

package/scripts/prove-predictive-insights.js

@@ -4,6 +4,7 @@
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
+const { ensureDir } = require('./fs-utils');
 
 const ROOT = path.join(__dirname, '..');
 
@@ -16,9 +17,6 @@ function resolveProofPaths() {
   };
 }
 
-function ensureDir(dirPath) {
-  fs.mkdirSync(dirPath, { recursive: true });
-}
 
 function buildStubTelemetry() {
   return {

package/scripts/prove-training-export.js

@@ -13,15 +13,13 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { execSync } = require('child_process');
+const { ensureDir } = require('./fs-utils');
 
 const ROOT = path.join(__dirname, '..');
 function getProofDir() {
   return process.env.THUMBGATE_PROOF_DIR || path.join(ROOT, 'proof');
 }
 
-function ensureDir(d) {
-  if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
-}
 
 function runTests() {
   try {

package/scripts/prove-workflow-contract.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 const fs = require('node:fs');
 const path = require('node:path');
+const { ensureDir } = require('./fs-utils');
 const {
   runWorkflowContractValidation,
 } = require('./validate-workflow-contract');
@@ -8,11 +9,6 @@ const {
 const PROJECT_ROOT = path.join(__dirname, '..');
 const DEFAULT_PROOF_DIR = path.join(PROJECT_ROOT, 'proof', 'workflow-contract');
 
-function ensureDir(dirPath) {
-  if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true });
-  }
-}
 
 function toMarkdown(report) {
   const lines = [

package/scripts/ralph-loop.js

@@ -0,0 +1,376 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const {
+  buildEngagementAudit,
+  DEFAULT_DRAFTS_PATH,
+  DEFAULT_LAUNCH_ASSETS_PATH,
+  DEFAULT_REPLY_STATE_PATH,
+  DEFAULT_TIMEZONE,
+} = require('./social-analytics/engagement-audit');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const DEFAULT_ARTIFACT_DIR = path.join(REPO_ROOT, '.artifacts', 'ralph-loop');
+const VALID_MODES = new Set(['all', 'engage', 'poll', 'audit', 'post']);
+const RALPH_STATE_PATHS = [
+  path.relative(REPO_ROOT, DEFAULT_REPLY_STATE_PATH),
+  path.relative(REPO_ROOT, DEFAULT_DRAFTS_PATH),
+  path.relative(REPO_ROOT, DEFAULT_LAUNCH_ASSETS_PATH),
+];
+const VALUE_OPTIONS = new Map([
+  ['--artifact-dir', 'artifactDir'],
+  ['--date', 'date'],
+  ['--mode', 'mode'],
+  ['--timezone', 'timezone'],
+]);
+
+function parseArgs(argv = []) {
+  const options = {
+    artifactDir: DEFAULT_ARTIFACT_DIR,
+    date: '',
+    dryRun: false,
+    mode: 'all',
+    timezone: DEFAULT_TIMEZONE,
+    replyStatePath: DEFAULT_REPLY_STATE_PATH,
+    draftsPath: DEFAULT_DRAFTS_PATH,
+    launchAssetsPath: DEFAULT_LAUNCH_ASSETS_PATH,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    index = consumeArg(options, argv, index);
+  }
+
+  options.mode = normalizeMode(options.mode);
+  return options;
+}
+
+function consumeArg(options, argv, index) {
+  const token = String(argv[index] || '').trim();
+  if (token === '--dry-run') {
+    options.dryRun = true;
+    return index;
+  }
+
+  const inline = token.match(/^(--[^=]+)=(.*)$/);
+  if (inline && VALUE_OPTIONS.has(inline[1])) {
+    setOption(options, VALUE_OPTIONS.get(inline[1]), inline[2]);
+    return index;
+  }
+
+  if (VALUE_OPTIONS.has(token) && argv[index + 1]) {
+    setOption(options, VALUE_OPTIONS.get(token), argv[index + 1]);
+    return index + 1;
+  }
+
+  return index;
+}
+
+function setOption(options, name, value) {
+  const trimmed = String(value || '').trim();
+  if (name === 'artifactDir') {
+    options.artifactDir = path.resolve(trimmed || DEFAULT_ARTIFACT_DIR);
+    return;
+  }
+  if (name === 'timezone') {
+    options.timezone = trimmed || DEFAULT_TIMEZONE;
+    return;
+  }
+  options[name] = trimmed || options[name];
+}
+
+function normalizeMode(mode) {
+  const normalized = String(mode || 'all').trim().toLowerCase();
+  if (!VALID_MODES.has(normalized)) {
+    throw new Error(`Invalid Ralph mode: ${mode}. Expected one of: ${[...VALID_MODES].join(', ')}`);
+  }
+  return normalized;
+}
+
+function hasAnyEnv(env, keys = []) {
+  return keys.some((key) => Boolean(env[key]));
+}
+
+function hasAllEnv(env, keys = []) {
+  return keys.every((key) => Boolean(env[key]));
+}
+
+function makeNodeStep(id, scriptPath, args = [], extra = {}) {
+  return {
+    id,
+    command: process.execPath,
+    args: [path.join(REPO_ROOT, scriptPath), ...args],
+    scriptPath,
+    type: 'node',
+    ...extra,
+  };
+}
+
+function withSkipReason(step, env) {
+  if (step.requiredEnvAll && !hasAllEnv(env, step.requiredEnvAll)) {
+    return {
+      ...step,
+      skipReason: `missing env: ${step.requiredEnvAll.filter((key) => !env[key]).join(', ')}`,
+    };
+  }
+  if (step.requiredEnvAny && !hasAnyEnv(env, step.requiredEnvAny)) {
+    return {
+      ...step,
+      skipReason: `missing one of: ${step.requiredEnvAny.join(', ')}`,
+    };
+  }
+  return step;
+}
+
+function wants(mode, names) {
+  return mode === 'all' || names.includes(mode);
+}
+
+function buildRalphSteps(options = {}, env = process.env) {
+  const mode = normalizeMode(options.mode || 'all');
+  const dryRun = Boolean(options.dryRun);
+  const steps = [];
+
+  if (wants(mode, ['poll'])) {
+    steps.push(makeNodeStep(
+      'poll-analytics',
+      'scripts/social-analytics/poll-all.js',
+      [],
+      {
+        stage: 'sense',
+        description: 'Polls configured social analytics for audience and attribution signals.',
+      }
+    ));
+  }
+
+  if (wants(mode, ['engage'])) {
+    steps.push(withSkipReason(makeNodeStep(
+      'sync-launch-assets',
+      'scripts/social-analytics/sync-launch-assets.js',
+      ['--limit=50', `--state-path=${options.launchAssetsPath || DEFAULT_LAUNCH_ASSETS_PATH}`],
+      {
+        stage: 'sense',
+        description: 'Syncs owned Zernio launch assets so reply monitoring anchors on current campaign posts.',
+        requiredEnvAll: ['ZERNIO_API_KEY'],
+      }
+    ), env));
+
+    const replyArgs = [];
+    if (dryRun) {
+      replyArgs.push('--dry-run');
+    }
+    steps.push(makeNodeStep(
+      'reply-monitor',
+      'scripts/social-reply-monitor.js',
+      replyArgs,
+      {
+        stage: 'engage',
+        description: 'Checks Reddit, X, and LinkedIn reply surfaces with platform-safe posting and draft rules.',
+      }
+    ));
+  }
+
+  if (mode === 'post') {
+    const postArgs = [];
+    if (dryRun) {
+      postArgs.push('--dry-run');
+    }
+    steps.push(makeNodeStep(
+      'daily-social-post',
+      'scripts/social-post-hourly.js',
+      postArgs,
+      {
+        stage: 'publish',
+        description: 'Runs the one-quality-post lane on demand. Ralph hourly mode does not call this step.',
+        requiredEnvAll: ['ZERNIO_API_KEY'],
+      }
+    ));
+  }
+
+  steps.push({
+    id: 'engagement-audit',
+    stage: 'prove',
+    type: 'internal',
+    description: 'Builds a machine-readable Ralph Loop audit from reply state, drafts, and launch assets.',
+  });
+
+  return steps.map((step) => withSkipReason(step, env));
+}
+
+function runExternalStep(step, env = process.env) {
+  const result = spawnSync(step.command, step.args, {
+    cwd: REPO_ROOT,
+    env,
+    encoding: 'utf8',
+    maxBuffer: 20 * 1024 * 1024,
+  });
+
+  return {
+    exitCode: typeof result.status === 'number' ? result.status : 1,
+    stdout: result.stdout || '',
+    stderr: result.stderr || '',
+    error: result.error ? result.error.message : '',
+  };
+}
+
+function runAuditStep(options = {}) {
+  return buildEngagementAudit({
+    date: options.date,
+    timezone: options.timezone || DEFAULT_TIMEZONE,
+    replyStatePath: options.replyStatePath || DEFAULT_REPLY_STATE_PATH,
+    draftsPath: options.draftsPath || DEFAULT_DRAFTS_PATH,
+    launchAssetsPath: options.launchAssetsPath || DEFAULT_LAUNCH_ASSETS_PATH,
+  });
+}
+
+function runStep(step, options = {}, deps = {}) {
+  const startedAt = new Date().toISOString();
+
+  if (step.skipReason) {
+    return {
+      id: step.id,
+      stage: step.stage,
+      status: 'skipped',
+      skipReason: step.skipReason,
+      startedAt,
+      finishedAt: new Date().toISOString(),
+    };
+  }
+
+  if (step.type === 'internal') {
+    const audit = runAuditStep(options);
+    return {
+      id: step.id,
+      stage: step.stage,
+      status: 'passed',
+      audit,
+      startedAt,
+      finishedAt: new Date().toISOString(),
+    };
+  }
+
+  const runner = deps.runner || runExternalStep;
+  const result = runner(step, deps.env || process.env);
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+
+  return {
+    id: step.id,
+    stage: step.stage,
+    status: result.exitCode === 0 ? 'passed' : 'failed',
+    exitCode: result.exitCode,
+    error: result.error || '',
+    stdoutTail: tail(result.stdout),
+    stderrTail: tail(result.stderr),
+    startedAt,
+    finishedAt: new Date().toISOString(),
+  };
+}
+
+function tail(text, maxChars = 4000) {
+  const value = String(text || '');
+  return value.length <= maxChars ? value : value.slice(value.length - maxChars);
+}
+
+function renderMarkdownReport(report) {
+  const lines = [
+    '# Ralph Loop Audience Engagement Report',
+    '',
+    `Generated: ${report.generatedAt}`,
+    `Mode: ${report.mode}`,
+    `Dry run: ${report.dryRun ? 'yes' : 'no'}`,
+    '',
+    'Ralph Mode keeps the Reliability Gateway pointed at acquisition: sense audience signals, engage safely, and preserve proof for Pre-Action Gates, DPO, and Thompson Sampling review.',
+    '',
+    '## Steps',
+    '',
+    '| Step | Stage | Status | Evidence |',
+    '|------|-------|--------|----------|',
+  ];
+
+  for (const step of report.steps) {
+    const evidence = step.skipReason || step.error || `exit ${step.exitCode ?? 0}`;
+    lines.push(`| ${step.id} | ${step.stage} | ${step.status} | ${String(evidence).replaceAll('|', '/')} |`);
+  }
+
+  lines.push(
+    '',
+    '## Audit',
+    '',
+    `- Checked: ${report.audit.totals.checked}`,
+    `- Replied: ${report.audit.totals.replied}`,
+    `- Drafted: ${report.audit.totals.drafted}`,
+    `- Skipped: ${report.audit.totals.skipped}`,
+    '',
+    'Authority evidence: docs/VERIFICATION_EVIDENCE.md',
+    ''
+  );
+
+  return `${lines.join('\n')}\n`;
+}
+
+function writeReports(report, artifactDir = DEFAULT_ARTIFACT_DIR) {
+  fs.mkdirSync(artifactDir, { recursive: true });
+  const jsonPath = path.join(artifactDir, 'ralph-loop-report.json');
+  const markdownPath = path.join(artifactDir, 'ralph-loop-report.md');
+  fs.writeFileSync(jsonPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
+  fs.writeFileSync(markdownPath, renderMarkdownReport(report), 'utf8');
+  return { jsonPath, markdownPath };
+}
+
+function runRalphLoop(options = {}, deps = {}) {
+  const normalized = {
+    ...parseArgs([]),
+    ...options,
+    mode: normalizeMode(options.mode || 'all'),
+  };
+  const env = deps.env || process.env;
+  const steps = buildRalphSteps(normalized, env);
+  const results = steps.map((step) => runStep(step, normalized, { ...deps, env }));
+  const auditStep = results.find((step) => step.id === 'engagement-audit');
+  const audit = auditStep?.audit ? auditStep.audit : runAuditStep(normalized);
+  const report = {
+    generatedAt: new Date().toISOString(),
+    mode: normalized.mode,
+    dryRun: Boolean(normalized.dryRun),
+    cadence: 'hourly_ci',
+    statePaths: RALPH_STATE_PATHS,
+    steps: results,
+    audit,
+  };
+  report.artifacts = writeReports(report, normalized.artifactDir || DEFAULT_ARTIFACT_DIR);
+  return report;
+}
+
+function isCliEntrypoint(argv = process.argv) {
+  return Boolean(argv[1] && path.resolve(argv[1]) === __filename);
+}
+
+if (isCliEntrypoint()) {
+  try {
+    const report = runRalphLoop(parseArgs(process.argv.slice(2)));
+    process.stdout.write(`\n[ralph-loop] Report: ${report.artifacts.jsonPath}\n`);
+    if (report.steps.some((step) => step.status === 'failed')) {
+      process.exitCode = 1;
+    }
+  } catch (err) {
+    console.error(`[ralph-loop] Fatal: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  DEFAULT_ARTIFACT_DIR,
+  RALPH_STATE_PATHS,
+  VALID_MODES,
+  buildRalphSteps,
+  isCliEntrypoint,
+  normalizeMode,
+  parseArgs,
+  renderMarkdownReport,
+  runRalphLoop,
+  runStep,
+  writeReports,
+};