thumbgate 1.4.1 → 1.4.3

package/scripts/social-analytics/db/schema.sql

@@ -30,3 +30,26 @@ CREATE TABLE IF NOT EXISTS follower_snapshots (
 
 CREATE INDEX IF NOT EXISTS idx_metrics_platform_date ON engagement_metrics(platform, metric_date);
 CREATE INDEX IF NOT EXISTS idx_metrics_published ON engagement_metrics(published_at);
+
+-- Marketing posts: tracks every post, video, and article published to any platform.
+-- Used to prevent double-posting and to measure marketing effort over time.
+CREATE TABLE IF NOT EXISTS marketing_posts (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  type          TEXT NOT NULL CHECK(type IN ('post','video','article','reply','thread')),
+  platform      TEXT NOT NULL,
+  account_id    TEXT,
+  post_id       TEXT,
+  post_url      TEXT,
+  title         TEXT,
+  content_hash  TEXT NOT NULL,
+  published_at  TEXT NOT NULL,
+  status        TEXT NOT NULL DEFAULT 'published' CHECK(status IN ('published','failed','skipped','draft')),
+  tags          TEXT,            -- JSON array
+  campaign      TEXT,            -- e.g. 'v1.4.1-launch', 'weekly-stats'
+  extra_json    TEXT,            -- arbitrary metadata
+  UNIQUE(platform, content_hash)
+);
+
+CREATE INDEX IF NOT EXISTS idx_mktg_platform_published ON marketing_posts(platform, published_at);
+CREATE INDEX IF NOT EXISTS idx_mktg_campaign ON marketing_posts(campaign);
+CREATE INDEX IF NOT EXISTS idx_mktg_type ON marketing_posts(type);

package/scripts/social-analytics/generate-instagram-card.js

@@ -19,10 +19,36 @@ try { sharp = require('sharp'); } catch { /* optional dependency */ }
 const REPO_ROOT = path.resolve(__dirname, '../..');
 const DEFAULT_OUTPUT = path.join(REPO_ROOT, '.thumbgate', 'instagram-card.png');
 
-async function generateInstagramCard(outputPath = DEFAULT_OUTPUT) {
+const CARD_VARIANTS = [
+  { headline: ['Your AI agent', 'has amnesia.'], sub: ['Give it memory that', 'survives restarts.'] },
+  { headline: ['CLAUDE.md is', 'a wish list.'], sub: ['ThumbGate is', 'enforcement.'] },
+  { headline: ['One thumbs-down.', 'Never again.'], sub: ['Mistakes become', 'prevention rules.'] },
+  { headline: ['33 pre-action', 'gates.'], sub: ['Block before execution.', 'Not after damage.'] },
+  { headline: ['AI agent broke', 'production?'], sub: ['That exact pattern', 'is now blocked forever.'] },
+  { headline: ['Fight AI', 'with AI.'], sub: ['Self-tuning gates.', 'Thompson Sampling.'] },
+  { headline: ['Your agent can\'t', 'disable this.'], sub: ['Self-protection gates.', '4 layers deep.'] },
+  { headline: ['NIST. SOC2.', 'OWASP. CWE.'], sub: ['Compliance tags on', 'every gate rule.'] },
+  { headline: ['500 actions.', '2.5 hours.'], sub: ['Budget enforcement.', 'No runaway agents.'] },
+  { headline: ['First AI-agent', 'cyberattack confirmed.'], sub: ['PreToolUse hooks', 'block before execution.'] },
+];
+
+async function generateInstagramCard(outputPath = DEFAULT_OUTPUT, options = {}) {
   const width = 1080;
   const height = 1080;
 
+  // Pick a variant: explicit, random, or rotate based on day
+  let variant;
+  if (options.variantIndex !== undefined) {
+    variant = CARD_VARIANTS[options.variantIndex % CARD_VARIANTS.length];
+  } else {
+    const dayOfYear = Math.floor((Date.now() - new Date(new Date().getFullYear(), 0, 0).getTime()) / 86400000);
+    const hourSlot = Math.floor(new Date().getHours() / 8); // 3 slots per day
+    variant = CARD_VARIANTS[(dayOfYear * 3 + hourSlot) % CARD_VARIANTS.length];
+  }
+
+  const h1 = options.headline || variant.headline;
+  const sub = options.sub || variant.sub;
+
   // Create SVG markup for the card
   const svg = `
     <svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">
@@ -31,18 +57,18 @@ async function generateInstagramCard(outputPath = DEFAULT_OUTPUT) {
 
       <!-- Main heading -->
       <text x="${width / 2}" y="400" font-size="72" font-weight="bold" text-anchor="middle" fill="#ffffff" font-family="Arial, sans-serif">
-        Your AI agent
+        ${h1[0]}
       </text>
       <text x="${width / 2}" y="490" font-size="72" font-weight="bold" text-anchor="middle" fill="#ffffff" font-family="Arial, sans-serif">
-        has amnesia.
+        ${h1[1]}
       </text>
 
       <!-- Subheading -->
       <text x="${width / 2}" y="620" font-size="48" text-anchor="middle" fill="#888888" font-family="Arial, sans-serif">
-        Give it memory that
+        ${sub[0]}
       </text>
       <text x="${width / 2}" y="680" font-size="48" text-anchor="middle" fill="#888888" font-family="Arial, sans-serif">
-        survives restarts.
+        ${sub[1]}
       </text>
 
       <!-- Brand -->

package/scripts/social-analytics/generate-slides.js

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * generate-slides.js
+ * Generates PNG slide frames for ThumbGate marketing short videos.
+ *
+ * 6 rotating templates — each tells a different story about the product.
+ * Templates are rotated by the post-scheduler so CI never reposts the
+ * same content within the configured cooldown window.
+ *
+ * Output: slide_01.png … slide_NN.png  +  manifest.json
+ * ffmpeg stitches them into MP4 via the video-autopilot CI workflow.
+ *
+ * Usage:
+ *   node scripts/social-analytics/generate-slides.js
+ *   node scripts/social-analytics/generate-slides.js --template=2
+ *   node scripts/social-analytics/generate-slides.js --template=auto --out=/tmp
+ */
+
+const { execSync } = require('node:child_process');
+const path = require('node:path');
+const fs = require('node:fs');
+
+// ---------------------------------------------------------------------------
+// Templates — 6 distinct story arcs, each 28-35 seconds
+// Edit content here; rendering logic is unchanged.
+// ---------------------------------------------------------------------------
+
+const TEMPLATES = {
+
+  // 1 — Force-push wipes PRs
+  1: {
+    name: 'force-push',
+    slides: [
+      { holdSeconds: 4, title: ['Your AI agent', 'just force-pushed', 'to main.'], subtitle: 'It wiped 3 open PRs.', lines: [], cta: null },
+      { holdSeconds: 4, title: ['You told it not to.', 'It did it again.'], subtitle: 'Prompts are suggestions — not constraints.', lines: [], cta: null },
+      { holdSeconds: 6, title: ['ThumbGate blocks it:'], subtitle: null, lines: ['→ Agent: git push --force origin main', '→ PreToolUse hook fires', '→ Gate #4: force-push to main', '✗ BLOCKED — rule auto-promoted', '  after 1 previous failure.'], cta: null },
+      { holdSeconds: 5, title: ['The feedback loop:'], subtitle: null, lines: ['👎  bad action captured', '→ lesson written to SQLite DB', '→ prevention rule generated', '→ PreToolUse gate activated', '✓  same mistake: blocked forever'], cta: null },
+      { holdSeconds: 6, title: ['ThumbGate', 'v1.4.1'], subtitle: 'Live GPT + local gates', lines: [], cta: { line1: 'Try the GPT →', line2: 'chatgpt.com/g/g-69dcfd1cd5f881918ae31874631d6f08-thumbgate' } },
+    ],
+  },
+
+  // 2 — Deleted prod config
+  2: {
+    name: 'deleted-config',
+    slides: [
+      { holdSeconds: 4, title: ['AI agent deleted', 'your prod config.'], subtitle: '"It looked unused."', lines: [], cta: null },
+      { holdSeconds: 4, title: ['2 hours of rollback.', 'For a file it', '"cleaned up".'], subtitle: null, lines: [], cta: null },
+      { holdSeconds: 6, title: ['Gate auto-created', 'after 1 failure:'], subtitle: null, lines: ['→ Agent: rm config/prod.json', '→ PreToolUse hook fires', '→ Pattern: rm config/*.json', '✗ BLOCKED — protected path', '  Add to .thumbgate/allowlist', '  to override explicitly.'], cta: null },
+      { holdSeconds: 5, title: ['Every 👎 becomes', 'a permanent gate.'], subtitle: null, lines: ['1 failure  → warn gate', '3 failures → hard block', 'No config change required.', 'Automatic.'], cta: null },
+      { holdSeconds: 6, title: ['ThumbGate', 'v1.4.1'], subtitle: 'npx thumbgate serve', lines: [], cta: { line1: 'Try the GPT →', line2: 'chatgpt.com/g/g-69dcfd1cd5f881918ae31874631d6f08-thumbgate' } },
+    ],
+  },
+
+  // 3 — Session amnesia
+  3: {
+    name: 'session-amnesia',
+    slides: [
+      { holdSeconds: 4, title: ['Every new session,', 'your AI agent', 'forgets everything.'], subtitle: null, lines: [], cta: null },
+      { holdSeconds: 5, title: ['You re-explain.', 'It breaks the', 'same thing.', 'You fix it again.'], subtitle: 'Sound familiar?', lines: [], cta: null },
+      { holdSeconds: 6, title: ['ThumbGate gives it', 'persistent memory:'], subtitle: null, lines: ['→ 👎 on bad action', '→ lesson stored in SQLite+FTS5', '→ retrieved next session', '→ gate blocks same mistake', '✓  learning that persists'], cta: null },
+      { holdSeconds: 5, title: ['Session 1 vs 50:'], subtitle: null, lines: ['Session 1: same mistakes', 'Session 10: fewer mistakes', 'Session 50: gates block them', '  before you even see them.', 'Compounding prevention.'], cta: null },
+      { holdSeconds: 6, title: ['ThumbGate', 'v1.4.1'], subtitle: 'Works with ChatGPT, Claude Code, Cursor, Codex CLI', lines: [], cta: { line1: 'Open the GPT →', line2: 'chatgpt.com/g/g-69dcfd1cd5f881918ae31874631d6f08-thumbgate' } },
+    ],
+  },
+
+  // 4 — Thompson Sampling (technical)
+  4: {
+    name: 'thompson-sampling',
+    slides: [
+      { holdSeconds: 4, title: ['How do gates decide', 'which lessons', 'matter most?'], subtitle: 'Thompson Sampling.', lines: [], cta: null },
+      { holdSeconds: 6, title: ['Each gate has a', 'Beta distribution:'], subtitle: null, lines: ['Gate starts: Beta(1,1) = uniform', '👎 on trigger: alpha += 1', '👍 no issue:   beta  += 1', '→ High alpha = high-priority gate', '→ Rarely triggered = auto-demoted'], cta: null },
+      { holdSeconds: 5, title: ['After ~20 cycles,', 'gates self-sort:'], subtitle: null, lines: ['force-push   → Beta(18,2)  HIGH', 'rm config    → Beta(12,3)  HIGH', 'npm audit    → Beta(2,15) demoted', '✓  signal rises, noise falls'], cta: null },
+      { holdSeconds: 5, title: ['No tuning.', 'No config.', 'Self-correcting.'], subtitle: 'The gate ranking adapts to your codebase.', lines: [], cta: null },
+      { holdSeconds: 6, title: ['ThumbGate', 'v1.4.1'], subtitle: 'Thompson Sampling + LanceDB vector search', lines: [], cta: { line1: 'Try the GPT →', line2: 'chatgpt.com/g/g-69dcfd1cd5f881918ae31874631d6f08-thumbgate' } },
+    ],
+  },
+
+  // 5 — 30-second install demo
+  5: {
+    name: 'install-demo',
+    slides: [
+      { holdSeconds: 4, title: ['Stop your AI agent', 'from making the', 'same mistakes.'], subtitle: 'Install in 30 seconds.', lines: [], cta: null },
+      { holdSeconds: 5, title: ['Step 1:'], subtitle: null, lines: ['npx thumbgate serve', '', '✓  MCP server running on :3001', '✓  SQLite lesson DB initialised', '✓  PreToolUse hook active'], cta: null },
+      { holdSeconds: 5, title: ['Step 2:'], subtitle: null, lines: ['Give a thumbs-down:', 'thumbgate feedback --down \\', '  "agent deleted prod config"', '', '→ Lesson captured + indexed'], cta: null },
+      { holdSeconds: 5, title: ['Step 3:', '(automatic)'], subtitle: null, lines: ['→ Prevention rule generated', '→ Gate created: rm config/*', '→ Next time agent tries it:', '✗ BLOCKED before execution'], cta: null },
+      { holdSeconds: 6, title: ['ThumbGate', 'v1.4.1'], subtitle: 'Free. Open source. No sign-up.', lines: [], cta: { line1: 'Open the GPT first', line2: 'chatgpt.com/g/g-69dcfd1cd5f881918ae31874631d6f08-thumbgate' } },
+    ],
+  },
+
+  // 6 — Before/After comparison
+  6: {
+    name: 'before-after',
+    slides: [
+      { holdSeconds: 4, title: ['Before ThumbGate:'], subtitle: null, lines: ['Agent runs dangerous command', 'You notice after deploy', 'You write a rule in CLAUDE.md', 'Agent ignores it next session', 'Repeat forever.'], cta: null },
+      { holdSeconds: 4, title: ['After ThumbGate:'], subtitle: null, lines: ['Agent tries dangerous command', '✗ BLOCKED by PreToolUse gate', 'Gate was promoted from your 👎', '✓  Never reaches production'], cta: null },
+      { holdSeconds: 5, title: ['The difference:'], subtitle: null, lines: ['CLAUDE.md   = suggestion', 'ThumbGate   = enforcement', '', 'Rules in files get ignored.', 'Gates cannot be ignored.'], cta: null },
+      { holdSeconds: 5, title: ['What changes:'], subtitle: null, lines: ['→ mistakes blocked pre-execution', '→ lessons persist across sessions', '→ gates auto-promote from failures', '→ DPO export for fine-tuning', '✓  compounding safety over time'], cta: null },
+      { holdSeconds: 6, title: ['ThumbGate', 'v1.4.1'], subtitle: 'Free + Open Source', lines: [], cta: { line1: 'Try the GPT →', line2: 'chatgpt.com/g/g-69dcfd1cd5f881918ae31874631d6f08-thumbgate' } },
+    ],
+  },
+
+};
+
+// ---------------------------------------------------------------------------
+// Python renderer (unchanged — handles all templates via SLIDES var)
+// ---------------------------------------------------------------------------
+
+function buildPythonScript(slides, outDir) {
+  return `
+import os, json as _json
+from PIL import Image, ImageDraw, ImageFont
+
+W, H = 1080, 1920
+OUT_DIR = ${JSON.stringify(outDir)}
+os.makedirs(OUT_DIR, exist_ok=True)
+
+FONT_PATHS = {
+    'bold':    '/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf',
+    'regular': '/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf',
+    'mono':    '/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf',
+}
+
+def font(name, size):
+    try: return ImageFont.truetype(FONT_PATHS.get(name, FONT_PATHS['regular']), size)
+    except: return ImageFont.load_default()
+
+SLIDES = _json.loads(${JSON.stringify(JSON.stringify(slides))})
+
+def bg():
+    img = Image.new('RGB', (W, H), '#0a0a0f')
+    d = ImageDraw.Draw(img)
+    for i in range(H):
+        r = i/H
+        d.line([(0,i),(W,i)], fill=(int(10+8*(1-r)), int(10+2*(1-r)), int(15+30*(1-r))))
+    return img, d
+
+def draw_slide(s, idx):
+    img, d = bg()
+    d.rectangle([(0,0),(W,8)], fill='#6366f1')
+    d.rectangle([(0,H-8),(W,H)], fill='#6366f1')
+    y = 200
+    for tl in s.get('title', []):
+        d.text((80, y), tl, font=font('bold', 76), fill='#ffffff')
+        y += 95
+    y += 20
+    sub = s.get('subtitle')
+    if sub:
+        d.text((80, y), sub, font=font('regular', 44), fill='#8888aa')
+        y += 65
+    y += 20
+    lines = s.get('lines', [])
+    if lines:
+        d.rectangle([(40, y-20),(W-40, y+len(lines)*58+25)], fill='#12121e', outline='#2a2a3f', width=2)
+        for line in lines:
+            px = 70
+            if line.startswith('✗'):
+                d.text((px, y), '✗', font=font('bold', 38), fill='#ef4444')
+                d.text((px+40, y), line[1:], font=font('mono', 36), fill='#ffaaaa')
+            elif line.startswith('✓'):
+                d.text((px, y), '✓', font=font('bold', 38), fill='#22c55e')
+                d.text((px+40, y), line[1:], font=font('mono', 36), fill='#aaffaa')
+            elif line.startswith('→'):
+                d.text((px, y), '→', font=font('regular', 38), fill='#6366f1')
+                d.text((px+40, y), line[1:], font=font('mono', 36), fill='#d0d8f0')
+            elif line.startswith('👎'):
+                d.text((px, y), line, font=font('mono', 36), fill='#fbbf24')
+            else:
+                d.text((px, y), line, font=font('mono', 36), fill='#d0d8f0')
+            y += 58
+    cta = s.get('cta')
+    if cta:
+        cy = H - 320
+        d.rectangle([(60, cy),(W-60, cy+180)], fill='#6366f1')
+        d.text((80, cy+24), cta['line1'], font=font('bold', 56), fill='#ffffff')
+        d.text((80, cy+100), cta['line2'], font=font('regular', 38), fill='#e0e8ff')
+    img.save(os.path.join(OUT_DIR, f'slide_{idx:02d}.png'), 'PNG')
+    print(f'  Wrote slide_{idx:02d}.png')
+
+for i, slide in enumerate(SLIDES): draw_slide(slide, i+1)
+print(f'Generated {len(SLIDES)} slides → {OUT_DIR}')
+`;
+}
+
+// ---------------------------------------------------------------------------
+// Template selector
+// ---------------------------------------------------------------------------
+
+/**
+ * Pick the next template to use, avoiding recent repeats.
+ * Reads marketing DB if available; falls back to round-robin by hour.
+ */
+function pickTemplate(requestedId) {
+  if (requestedId && requestedId !== 'auto') {
+    const id = Number.parseInt(requestedId, 10);
+    if (!TEMPLATES[id]) { console.error(`Unknown template id: ${id}`); process.exit(1); }
+    return id;
+  }
+
+  // Try to pick least-recently-used from marketing DB
+  try {
+    const db = require('./db/marketing-db');
+    const recent = db.list({ type: 'video', days: 30, limit: 100 });
+    const usedTemplates = new Set(
+      recent.map(r => { try { return JSON.parse(r.extra_json || '{}').templateId; } catch { return null; } }).filter(Boolean)
+    );
+    const allIds = Object.keys(TEMPLATES).map(Number);
+    const unused = allIds.filter(id => !usedTemplates.has(id));
+    if (unused.length > 0) return unused[0]; // pick first unused
+    // All used — pick oldest
+    const templateCounts = {};
+    for (const r of recent) {
+      try { const t = JSON.parse(r.extra_json || '{}').templateId; if (t) templateCounts[t] = (templateCounts[t] || 0) + 1; } catch {}
+    }
+    const sortedIds = [...allIds];
+    sortedIds.sort((a, b) => (templateCounts[a] || 0) - (templateCounts[b] || 0));
+    return sortedIds[0];
+  } catch {
+    // Fallback: round-robin by 4-hour block
+    const block = Math.floor(Date.now() / (4 * 3600 * 1000));
+    const ids = Object.keys(TEMPLATES).map(Number);
+    return ids[block % ids.length];
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+
+function main() {
+  const args = process.argv.slice(2);
+  const outDir = args.find(a => a.startsWith('--out='))?.slice(6) || path.join(__dirname);
+  const campaign = args.find(a => a.startsWith('--campaign='))?.slice(11) || 'default';
+  const templateArg = args.find(a => a.startsWith('--template='))?.slice(11) || 'auto';
+
+  const templateId = pickTemplate(templateArg);
+  const template = TEMPLATES[templateId];
+
+  console.log(`[generate-slides] template=${templateId}(${template.name}) campaign=${campaign} out=${outDir}`);
+
+  const pyScript = buildPythonScript(template.slides, outDir);
+  const tmpPy = path.join(require('node:os').tmpdir(), 'thumbgate_slides.py');
+  fs.writeFileSync(tmpPy, pyScript);
+
+  try {
+    execSync(`python3 ${tmpPy}`, { stdio: 'inherit' });
+  } catch (err) {
+    console.error('[generate-slides] Python render failed:', err.message);
+    process.exit(1);
+  }
+
+  const manifest = {
+    templateId,
+    templateName: template.name,
+    campaign,
+    generatedAt: new Date().toISOString(),
+    slides: template.slides.map((s, i) => ({
+      file: `slide_${String(i + 1).padStart(2, '0')}.png`,
+      holdSeconds: s.holdSeconds,
+    })),
+    totalDuration: template.slides.reduce((sum, s) => sum + s.holdSeconds, 0),
+  };
+  fs.writeFileSync(path.join(outDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+  console.log(`[generate-slides] Done. template=${templateId} duration=${manifest.totalDuration}s`);
+}
+
+main();

package/scripts/social-analytics/post-video.js

@@ -0,0 +1,316 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * post-video.js
+ * Generates a marketing short video and posts it to TikTok, YouTube, and
+ * Instagram Reels via Zernio. Tracks everything in the marketing DB to
+ * prevent double-posting.
+ *
+ * Usage:
+ *   node scripts/social-analytics/post-video.js
+ *   node scripts/social-analytics/post-video.js --campaign=v1.4.1 --dry-run
+ *   node scripts/social-analytics/post-video.js --video=/path/to/custom.mp4
+ *
+ * Required env:
+ *   ZERNIO_API_KEY
+ * Optional env (overrides hardcoded account IDs):
+ *   ZERNIO_TIKTOK_ACCOUNT_ID
+ *   ZERNIO_YOUTUBE_ACCOUNT_ID
+ *   ZERNIO_INSTAGRAM_ACCOUNT_ID
+ */
+
+const { execFileSync, execSync } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { loadLocalEnv } = require('./load-env');
+
+loadLocalEnv();
+
+const { hashContent, isDuplicate, record } = require('./db/marketing-db');
+
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+
+const ZERNIO_BASE = 'https://zernio.com/api/v1';
+
+const ACCOUNTS = {
+  tiktok:    process.env.ZERNIO_TIKTOK_ACCOUNT_ID    || '69bee0fd6cb7b8cf4c8b2425',
+  youtube:   process.env.ZERNIO_YOUTUBE_ACCOUNT_ID   || '69c14dc36cb7b8cf4c91c1e4',
+  instagram: process.env.ZERNIO_INSTAGRAM_ACCOUNT_ID || '69bed6ad6cb7b8cf4c8b0865',
+};
+
+// Per-platform cooldown in hours — prevents over-posting even when CI fires every 4h
+const PLATFORM_COOLDOWN_HOURS = {
+  tiktok:    4,   // up to 6 videos/day — TikTok rewards frequency
+  instagram: 8,   // up to 3 Reels/day
+  youtube:   12,  // 1-2 Shorts/day
+};
+
+const CAPTIONS = {
+  tiktok: `Your AI agent deleted prod config because it "looked unused" 😬
+
+ThumbGate v1.4.1 intercepts BEFORE the action runs. Checks it against lessons from past failures. Blocks it permanently.
+
+👎 feedback → lesson DB → prevention rule → physical gate
+
+Not a prompt. A block.
+
+npx thumbgate serve — free + open source
+Try the live GPT first: https://chatgpt.com/g/g-69dcfd1cd5f881918ae31874631d6f08-thumbgate
+github.com/IgorGanapolsky/ThumbGate
+
+#ClaudeCode #AIAgents #DevTools #TechTok #Coding #SoftwareDev #AITools #Programming #DevTok`,
+
+  youtube: `ThumbGate v1.4.1: How to stop AI coding agents from repeating mistakes
+
+Your agent force-pushed to main. Deleted prod config. Ran the wrong migration. You told it not to. Next session — same mistake.
+
+ThumbGate solves this with pre-action gates: every 👎 becomes a lesson, every lesson becomes a gate, every gate is enforced via PreToolUse hooks.
+
+v1.4.1: Thompson Sampling · LanceDB vector search · SQLite+FTS5 lesson DB
+
+Live GPT demo: https://chatgpt.com/g/g-69dcfd1cd5f881918ae31874631d6f08-thumbgate
+Free + open source: https://github.com/IgorGanapolsky/ThumbGate
+npx thumbgate serve
+
+#ClaudeCode #AIAgents #DevTools #Shorts`,
+
+  instagram: `AI agent deleted prod config because it "looked unused" 😬
+
+ThumbGate v1.4.1: pre-action safety gates that physically block known-bad patterns before they run.
+
+👎 → lesson DB → prevention rule → blocked forever
+
+Live GPT demo: chatgpt.com/g/g-69dcfd1cd5f881918ae31874631d6f08-thumbgate
+Free + open source. Link in bio 👆
+
+#AIAgents #ClaudeCode #DevTools #Coding #TechTok #SoftwareDev #AITools #MachineLearning #BuildInPublic`,
+};
+
+const YT_TITLE = 'ThumbGate v1.4.1: Stop AI Agents From Repeating Mistakes #shorts';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function parseArgs(argv) {
+  const opts = { dryRun: false, campaign: 'default', videoPath: null, platforms: null, template: 'auto' };
+  for (const arg of argv) {
+    if (arg === '--dry-run') opts.dryRun = true;
+    else if (arg.startsWith('--campaign=')) opts.campaign = arg.slice(11);
+    else if (arg.startsWith('--video=')) opts.videoPath = arg.slice(8);
+    else if (arg.startsWith('--platforms=')) opts.platforms = arg.slice(12).split(',');
+    else if (arg.startsWith('--template=')) opts.template = arg.slice(11);
+  }
+  return opts;
+}
+
+function requireKey() {
+  const k = process.env.ZERNIO_API_KEY;
+  if (!k) throw new Error('ZERNIO_API_KEY env var is required');
+  return k;
+}
+
+async function zernioUpload(apiKey, filePath) {
+  const out = execFileSync('curl', [
+    '-s',
+    '-X', 'POST',
+    `${ZERNIO_BASE}/media`,
+    '-H', `Authorization: Bearer ${apiKey}`,
+    '-F', `files=@${filePath}`,
+  ], { maxBuffer: 10 * 1024 * 1024 }).toString();
+
+  const data = JSON.parse(out);
+  const files = data.files || [];
+  if (!files.length) throw new Error(`Zernio upload failed: ${out}`);
+  return files[0].url;
+}
+
+async function zernioPost(apiKey, { platform, accountId, title, content, mediaUrl, mediaType = 'video' }) {
+  const body = {
+    content,
+    mediaItems: [{ url: mediaUrl, type: mediaType }],
+    platforms: [{ platform, accountId }],
+    publishNow: true,
+  };
+  if (title) body.title = title;
+
+  const out = execFileSync('curl', [
+    '-s',
+    '-X', 'POST',
+    `${ZERNIO_BASE}/posts`,
+    '-H', `Authorization: Bearer ${apiKey}`,
+    '-H', 'Content-Type: application/json',
+    '-d', JSON.stringify(body),
+  ], { maxBuffer: 5 * 1024 * 1024 }).toString();
+
+  return JSON.parse(out);
+}
+
+// ---------------------------------------------------------------------------
+// Video generation
+// ---------------------------------------------------------------------------
+
+function generateVideo(outDir, template = 'auto', campaign = 'default') {
+  const slidesScript = path.join(__dirname, 'generate-slides.js');
+  const concatFile = path.join(outDir, 'concat.txt');
+  const videoOut = path.join(outDir, 'thumbgate-short.mp4');
+
+  console.log('[post-video] Generating slides...');
+  execFileSync(process.execPath, [
+    slidesScript,
+    `--out=${outDir}`,
+    `--template=${template}`,
+    `--campaign=${campaign}`,
+  ], { stdio: 'inherit' });
+
+  // Build ffmpeg concat file from manifest
+  const manifest = JSON.parse(fs.readFileSync(path.join(outDir, 'manifest.json'), 'utf8'));
+  const concatLines = manifest.slides.map(s => `file '${path.join(outDir, s.file)}'\nduration ${s.holdSeconds}`);
+  const lastSlide = manifest.slides[manifest.slides.length - 1];
+  concatLines.push(`file '${path.join(outDir, lastSlide.file)}'`);
+  fs.writeFileSync(concatFile, concatLines.join('\n'));
+
+  console.log('[post-video] Rendering video...');
+  execSync(
+    `ffmpeg -y -f concat -safe 0 -i "${concatFile}" \
+      -vf "scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2,setsar=1" \
+      -c:v libx264 -r 30 -pix_fmt yuv420p -movflags +faststart \
+      "${videoOut}"`,
+    { stdio: 'pipe' }
+  );
+
+  const size = (fs.statSync(videoOut).size / 1024).toFixed(0);
+  console.log(`[post-video] Video ready: ${videoOut} (${size} KB, ${manifest.totalDuration}s)`);
+  return videoOut;
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+function prepareVideo(opts) {
+  let videoPath = opts.videoPath;
+  let templateId = opts.template;
+  if (!videoPath) {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'thumbgate-video-'));
+    videoPath = generateVideo(tmpDir, opts.template, opts.campaign);
+    // Read back the chosen template id from manifest
+    try {
+      const manifest = JSON.parse(fs.readFileSync(path.join(tmpDir, 'manifest.json'), 'utf8'));
+      templateId = String(manifest.templateId || opts.template);
+    } catch {}
+  }
+  return { videoPath, templateId };
+}
+
+function buildPlatformPlan(platform, baseHash) {
+  const caption = CAPTIONS[platform];
+  if (!caption) {
+    console.warn(`[post-video] No caption for platform: ${platform} — skipping`);
+    return null;
+  }
+
+  const contentHash = hashContent(`${baseHash}::${platform}`);
+  const cooldownHours = PLATFORM_COOLDOWN_HOURS[platform] || 4;
+  return { platform, caption, contentHash, cooldownDays: cooldownHours / 24 };
+}
+
+function duplicateResult(plan) {
+  const existing = isDuplicate(plan.platform, plan.contentHash, plan.cooldownDays);
+  if (!existing) return null;
+  console.log(`[post-video] SKIP ${plan.platform} — already posted (${existing.published_at}): ${existing.post_url}`);
+  return { platform: plan.platform, status: 'skipped', reason: 'duplicate', existing };
+}
+
+function recordPostOutcome({ plan, status, postUrl, error, campaign, mediaUrl, templateId, response }) {
+  if (status === 'published') {
+    console.log(`[post-video] ✓ ${plan.platform}: ${postUrl}`);
+    record({ type: 'video', platform: plan.platform, contentHash: plan.contentHash, postUrl, campaign,
+      tags: ['v1.4.1', 'short', campaign],
+      extra: { mediaUrl, templateId, zernioPostId: response.post?._id } });
+    return;
+  }
+
+  console.error(`[post-video] ✗ ${plan.platform}: ${error}`);
+  record({ type: 'video', platform: plan.platform, contentHash: plan.contentHash, status: 'failed', campaign,
+    extra: { error } });
+}
+
+async function processPlatform(plan, context) {
+  const duplicate = duplicateResult(plan);
+  if (duplicate) return duplicate;
+
+  if (context.dryRun) {
+    console.log(`[post-video] DRY-RUN ${plan.platform} — would post video`);
+    return { platform: plan.platform, status: 'dry-run' };
+  }
+
+  try {
+    if (!context.mediaUrl) {
+      console.log(`[post-video] Uploading video to Zernio...`);
+      context.mediaUrl = await zernioUpload(context.apiKey, context.videoPath);
+      console.log(`[post-video] Uploaded: ${context.mediaUrl}`);
+    }
+
+    console.log(`[post-video] Posting to ${plan.platform}...`);
+    const response = await zernioPost(context.apiKey, {
+      platform: plan.platform,
+      accountId: ACCOUNTS[plan.platform],
+      title: plan.platform === 'youtube' ? YT_TITLE : undefined,
+      content: plan.caption,
+      mediaUrl: context.mediaUrl,
+    });
+
+    const platformResult = response.post?.platforms?.[0] || {};
+    const status = platformResult.status || 'unknown';
+    const postUrl = platformResult.platformPostUrl || '';
+    const error = platformResult.errorMessage || response.error || '';
+    recordPostOutcome({ plan, status, postUrl, error, campaign: context.campaign,
+      mediaUrl: context.mediaUrl, templateId: context.templateId, response });
+    return { platform: plan.platform, status, postUrl, error };
+  } catch (err) {
+    console.error(`[post-video] ✗ ${plan.platform} error: ${err.message}`);
+    return { platform: plan.platform, status: 'error', error: err.message };
+  }
+}
+
+function statusIcon(status) {
+  if (status === 'published') return '✓';
+  if (['skipped', 'dry-run'].includes(status)) return '→';
+  return '✗';
+}
+
+function printSummary(results) {
+  console.log('\n[post-video] Summary:');
+  for (const r of results) {
+    const icon = statusIcon(r.status);
+    console.log(`  ${icon} ${r.platform}: ${r.status}${r.postUrl ? ' — ' + r.postUrl : ''}${r.error ? ' — ' + r.error : ''}`);
+  }
+}
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  const apiKey = opts.dryRun ? null : requireKey();
+  const platforms = opts.platforms || ['tiktok', 'youtube', 'instagram'];
+  console.log(`[post-video] campaign=${opts.campaign} platforms=${platforms.join(',')} dryRun=${opts.dryRun}`);
+
+  const { videoPath, templateId } = prepareVideo(opts);
+  const baseHash = hashContent(`video::template-${templateId}::${opts.campaign}`);
+  const context = { apiKey, campaign: opts.campaign, dryRun: opts.dryRun, mediaUrl: null, templateId, videoPath };
+  const plans = platforms.map(platform => buildPlatformPlan(platform, baseHash)).filter(Boolean);
+  const results = [];
+
+  for (const plan of plans) {
+    results.push(await processPlatform(plan, context));
+  }
+
+  printSummary(results);
+
+  return results;
+}
+
+main().catch(err => { console.error(err.message); process.exit(1); });