atris 3.30.0 → 3.30.2

package/commands/workflow.js

@@ -555,7 +555,7 @@ async function planAtris(userInput = null) {
   printConfidenceGate('   ');
   console.log('3) Write tasks to atris/TODO.md under ## Backlog');
   console.log('   Format: - **T#:** Description [explore|execute]');
-  console.log('4) Log to atris/team/navigator/journal/YYYY-MM-DD.md');
+  console.log('4) Log to atris/team/navigator/logs/YYYY-MM-DD.md');
   console.log('   (Task, Delivered, User reaction, Pattern)');
   if (atris2Mode) {
     console.log('5) EXECUTE MODE ENABLED: Will execute tasks directly.');
@@ -636,7 +636,7 @@ async function planAtris(userInput = null) {
     userPrompt += `   - Each task: one job, clear exit condition\n`;
     userPrompt += `   - Include file:line references from MAP.md\n\n`;
     userPrompt += `STEP 5: Log to your journal\n`;
-    userPrompt += `   - Write to atris/team/navigator/journal/YYYY-MM-DD.md\n`;
+    userPrompt += `   - Write to atris/team/navigator/logs/YYYY-MM-DD.md\n`;
     userPrompt += `   - Include: Task, Delivered, User reaction, Pattern\n`;
     userPrompt += `   - Your journal is how you learn — record what worked\n\n`;
     userPrompt += `Start planning now. Read MAP.md for file references.`;
@@ -900,7 +900,7 @@ async function doAtris() {
   console.log('3) Execute step-by-step. Run tests as you go.');
   console.log('4) Before completion, rerun the gate against proof and residual risk');
   console.log('5) When done, move task to ## Completed');
-  console.log('6) Log to atris/team/executor/journal/YYYY-MM-DD.md');
+  console.log('6) Log to atris/team/executor/logs/YYYY-MM-DD.md');
   console.log('   (Task, Delivered, Errors hit, Learned)');
   console.log('');
   console.log('⛔ Do NOT plan — just execute what\'s written.');
@@ -989,7 +989,7 @@ async function doAtris() {
     userPrompt += `4. Execute task: Use file edit tools, terminal commands, etc.\n`;
     userPrompt += `5. Before completion, rerun the gate against proof and residual risk\n`;
     userPrompt += `6. Move task to ## Completed in TODO.md\n`;
-    userPrompt += `7. Log to atris/team/executor/journal/YYYY-MM-DD.md\n`;
+    userPrompt += `7. Log to atris/team/executor/logs/YYYY-MM-DD.md\n`;
     userPrompt += `   (Task, Delivered, Errors hit, Learned)\n`;
     userPrompt += `8. Use MAP.md to navigate codebase\n\n`;
     userPrompt += `DO NOT just describe what you would do - actually edit files and execute commands!\n`;
@@ -1288,7 +1288,7 @@ async function reviewAtris() {
     console.log('4) Confirm active task state is clean: no unresolved Backlog/In Progress/Blocked rows for the reviewed work.');
     console.log('   If durable task state changed, regenerate the readable view with `atris task render --out atris/TODO.md`.');
     console.log('   Do not hand-delete rendered completed history; use `atris task list --status done` for the ledger.');
-    console.log('5) Log to atris/team/validator/journal/YYYY-MM-DD.md');
+    console.log('5) Log to atris/team/validator/logs/YYYY-MM-DD.md');
     console.log('   (Task, Result, Issues found, Learned)');
     console.log('6) If anything surprised you, append to atris/lessons.md.');
     console.log('');
@@ -1389,7 +1389,7 @@ async function reviewAtris() {
     userPrompt += `  • Confirm active task state is clean — no unresolved Backlog/In Progress/Blocked rows for reviewed work.\n`;
     userPrompt += `    If durable task state changed, regenerate the readable view with \`atris task render --out atris/TODO.md\`.\n`;
     userPrompt += `    Do not hand-delete rendered completed history; if a task fails, move or mark it blocked with a note.\n`;
-    userPrompt += `  • Log to atris/team/validator/journal/YYYY-MM-DD.md\n`;
+    userPrompt += `  • Log to atris/team/validator/logs/YYYY-MM-DD.md\n`;
     userPrompt += `    (Task, Result, Issues found, Learned)\n`;
     userPrompt += `  • If anything surprised you, append to atris/lessons.md\n`;
     userPrompt += `  • EVOLUTION: If you see drift in the logs, propose a tool upgrade.\n\n`;

package/commands/xp.js

@@ -2048,6 +2048,7 @@ async function syncAgentXp(args = []) {
   if (dryRun) return preview;
 
   const token = readFlag(args, '--token', process.env.ATRIS_AGENTXP_SYNC_TOKEN || process.env.AGENTXP_SYNC_TOKEN || '');
+  const envToken = process.env.ATRIS_TOKEN && process.env.ATRIS_TOKEN.trim() ? process.env.ATRIS_TOKEN.trim() : '';
   const options = {
     method: 'POST',
     body: preview.packet,
@@ -2055,6 +2056,8 @@ async function syncAgentXp(args = []) {
   };
   if (token) {
     options.headers = { 'X-AgentXP-Sync-Token': token };
+  } else if (envToken) {
+    options.token = envToken;
   } else {
     const ensured = await ensureValidCredentials(apiRequestJson);
     if (ensured.error) {
@@ -2106,7 +2109,16 @@ function renderSync(payload) {
     console.log('Login auth mapped this sync to your Atris account.');
   }
   console.log(`Packet ${payload.packet_hash}`);
-  console.log(`Leaderboard: ${AGENTXP_LEADERBOARD_URL}`);
+  const publicAccepted = asNumber(server.public_accepted_count);
+  const internalAccepted = asNumber(server.internal_accepted_count);
+  if (publicAccepted > 0) {
+    console.log(`Published to AgentXP: ${AGENTXP_LEADERBOARD_URL}`);
+  } else if (internalAccepted > 0 || server.private_agentxp) {
+    console.log('Saved internally. Public AgentXP was not updated.');
+    console.log('To publish publicly, run: atris xp sync --all --public');
+  } else {
+    console.log(`Leaderboard: ${AGENTXP_LEADERBOARD_URL}`);
+  }
 }
 
 function render(payload) {

package/commands/youtube.js

@@ -1,15 +1,24 @@
 const { apiRequestJson } = require('../utils/api');
 const { ensureValidCredentials } = require('../utils/auth');
+const { spawnSync } = require('child_process');
+const https = require('https');
 
 const DEFAULT_QUERY = 'Extract main topics, key insights, and actionable takeaways.';
 const DEFAULT_TIMEOUT_MS = 300000;
+const LOCAL_TRANSCRIPT_MAX_BYTES = 5 * 1024 * 1024;
+const LOCAL_TRANSCRIPT_MAX_CHARS = 250000;
+const ALLOWED_CAPTION_HOST_SUFFIXES = [
+  'youtube.com',
+  'googlevideo.com',
+  'youtubei.googleapis.com',
+];
 
 function showYoutubeHelp(output = console.log, commandName = 'atris youtube') {
   output('');
   output(`Usage: ${commandName} process <youtube-url> [options]`);
   output(`       ${commandName} <youtube-url> [options]`);
   output('');
-  output('Process a YouTube video through Atris using Gemini native video analysis.');
+  output('Process a YouTube video through Atris using transcript-first analysis.');
   output('');
   output('Options:');
   output('  --query, -q <text>  Focus question for the analysis');
@@ -108,9 +117,190 @@ function buildYoutubePayload(options) {
   };
   if (options.agentId) payload.agent_id = options.agentId;
   if (options.storeAsKnowledge) payload.store_as_knowledge = true;
+  if (options.localTranscript?.transcriptText) {
+    payload.transcript_text = options.localTranscript.transcriptText;
+    if (options.localTranscript.language) payload.transcript_language = options.localTranscript.language;
+    if (options.localTranscript.durationSeconds) payload.duration_seconds = options.localTranscript.durationSeconds;
+  }
+  if (options.cacheTranscript !== undefined) {
+    payload.cache_transcript = Boolean(options.cacheTranscript);
+  }
   return payload;
 }
 
+function resultErrorText(result) {
+  const raw = result?.error || result?.text || 'unknown error';
+  if (typeof raw === 'string') return raw;
+  try {
+    return JSON.stringify(raw);
+  } catch {
+    return String(raw);
+  }
+}
+
+function shouldRetryWithLocalTranscript(result) {
+  if (!result || result.ok) return false;
+  if (result.status === 502) return true;
+  if (result.status !== 400) return false;
+  return /YouTube video is not publicly accessible|oEmbed|metadata lookup failed/i.test(resultErrorText(result));
+}
+
+function youtubeFailureError(result) {
+  const hint = result.status === 401
+    ? ' Run "atris login --force".'
+    : result.status === 402
+      ? ' Check Atris credits.'
+      : '';
+  return new Error(`YouTube processing failed (${result.status}): ${resultErrorText(result)}.${hint}`);
+}
+
+function captionHostAllowed(urlString) {
+  try {
+    const parsed = new URL(urlString);
+    if (parsed.protocol !== 'https:') return false;
+    const hostname = parsed.hostname.toLowerCase().replace(/\.$/, '');
+    return ALLOWED_CAPTION_HOST_SUFFIXES.some((suffix) => (
+      hostname === suffix || hostname.endsWith(`.${suffix}`)
+    ));
+  } catch {
+    return false;
+  }
+}
+
+function chooseCaptionTrack(info = {}) {
+  const preferred = ['en', 'en-orig', 'en-US', 'en-GB'];
+  const chooseFrom = (trackSets = {}) => {
+    for (const language of preferred) {
+      for (const track of trackSets[language] || []) {
+        if (track?.url && ['json3', 'vtt', 'srv3', 'ttml'].includes(track.ext)) return { language, track };
+      }
+    }
+    for (const [language, tracks] of Object.entries(trackSets)) {
+      for (const track of tracks || []) {
+        if (track?.url) return { language, track };
+      }
+    }
+    return null;
+  };
+
+  return chooseFrom(info.subtitles) || chooseFrom(info.automatic_captions);
+}
+
+function fetchCaptionText(urlString, redirects = 0) {
+  if (!captionHostAllowed(urlString)) {
+    return Promise.resolve(null);
+  }
+
+  return new Promise((resolve) => {
+    const req = https.get(urlString, { timeout: 30000 }, (res) => {
+      if ([301, 302, 307, 308].includes(res.statusCode) && res.headers.location && redirects < 3) {
+        res.resume();
+        const nextUrl = new URL(res.headers.location, urlString).toString();
+        resolve(fetchCaptionText(nextUrl, redirects + 1));
+        return;
+      }
+
+      if (res.statusCode !== 200 || !captionHostAllowed(res.responseUrl || urlString)) {
+        res.resume();
+        resolve(null);
+        return;
+      }
+
+      const contentLength = Number(res.headers['content-length'] || 0);
+      if (contentLength > LOCAL_TRANSCRIPT_MAX_BYTES) {
+        res.resume();
+        resolve(null);
+        return;
+      }
+
+      const chunks = [];
+      let total = 0;
+      res.on('data', (chunk) => {
+        total += chunk.length;
+        if (total > LOCAL_TRANSCRIPT_MAX_BYTES) {
+          req.destroy();
+          resolve(null);
+          return;
+        }
+        chunks.push(chunk);
+      });
+      res.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+    });
+    req.on('timeout', () => req.destroy());
+    req.on('error', () => resolve(null));
+  });
+}
+
+function parseCaptionText(raw) {
+  const trimmed = String(raw || '').trimStart();
+  if (!trimmed) return '';
+
+  if (trimmed.startsWith('{')) {
+    try {
+      const payload = JSON.parse(trimmed);
+      const segments = [];
+      for (const event of payload.events || []) {
+        const text = (event.segs || [])
+          .map((piece) => piece.utf8 || '')
+          .join('')
+          .replace(/\s+/g, ' ')
+          .trim();
+        if (!text) continue;
+        if (segments[segments.length - 1] === text) continue;
+        segments.push(text);
+      }
+      return segments.join(' ');
+    } catch {
+      return '';
+    }
+  }
+
+  const segments = [];
+  for (const line of String(raw).split(/\r?\n/)) {
+    const stripped = line.trim();
+    if (!stripped) continue;
+    if (/^(WEBVTT|Kind:|Language:|NOTE|STYLE|REGION)/.test(stripped)) continue;
+    if (stripped.includes('-->')) continue;
+    if (/^\d+$/.test(stripped)) continue;
+    if (stripped.includes('<c>') || stripped.includes('</c>')) continue;
+    const text = stripped.replace(/<[^>]+>/g, '').replace(/\s+/g, ' ').trim();
+    if (!text) continue;
+    if (segments[segments.length - 1] === text) continue;
+    segments.push(text);
+  }
+  return segments.join(' ');
+}
+
+async function extractLocalTranscript(youtubeUrl, deps = {}) {
+  if (process.env.ATRIS_YOUTUBE_LOCAL_TRANSCRIPT === '0') return null;
+  const runner = deps.spawnSync || spawnSync;
+  const result = runner('yt-dlp', ['-J', '--skip-download', '--no-warnings', youtubeUrl], {
+    encoding: 'utf8',
+    timeout: 20000,
+    maxBuffer: 10 * 1024 * 1024,
+  });
+  if (result.error || result.status !== 0 || !result.stdout) return null;
+
+  let info;
+  try {
+    info = JSON.parse(result.stdout);
+  } catch {
+    return null;
+  }
+
+  const selected = chooseCaptionTrack(info);
+  if (!selected?.track?.url) return null;
+  const rawCaption = await (deps.fetchCaptionText || fetchCaptionText)(selected.track.url);
+  const transcript = parseCaptionText(rawCaption);
+  if (!transcript) return null;
+
+  return {
+    transcriptText: transcript.slice(0, LOCAL_TRANSCRIPT_MAX_CHARS),
+    language: selected.language || 'unknown',
+    durationSeconds: Number(info.duration || 0) || undefined,
+  };
+}
+
 async function processYoutube(options, deps = {}) {
   const apiFn = deps.apiRequestJson || apiRequestJson;
   const ensureFn = deps.ensureValidCredentials || ensureValidCredentials;
@@ -121,20 +311,42 @@ async function processYoutube(options, deps = {}) {
     throw new Error(detail ? `Authentication failed: ${detail}. Run "atris login".` : 'Not logged in. Run "atris login".');
   }
 
+  const localExtractor = deps.extractLocalTranscript || extractLocalTranscript;
+  let localTranscript = null;
+  try {
+    localTranscript = await localExtractor(options.youtubeUrl, deps);
+  } catch {
+    localTranscript = null;
+  }
+
+  if (localTranscript?.transcriptText) {
+    const transcriptResult = await apiFn('/agent/process_youtube', {
+      method: 'POST',
+      token: creds.token,
+      timeoutMs: options.timeoutMs,
+      retries: 0,
+      body: buildYoutubePayload({ ...options, localTranscript, cacheTranscript: false }),
+    });
+
+    if (transcriptResult.ok) {
+      return transcriptResult.data;
+    }
+
+    if (transcriptResult.status === 401 || transcriptResult.status === 402 || transcriptResult.status === 400) {
+      throw youtubeFailureError(transcriptResult);
+    }
+  }
+
   const result = await apiFn('/agent/process_youtube', {
     method: 'POST',
     token: creds.token,
     timeoutMs: options.timeoutMs,
+    retries: 0,
     body: buildYoutubePayload(options),
   });
 
   if (!result.ok) {
-    const hint = result.status === 401
-      ? ' Run "atris login --force".'
-      : result.status === 402
-        ? ' Check Atris credits.'
-        : '';
-    throw new Error(`YouTube processing failed (${result.status}): ${result.error || result.text || 'unknown error'}.${hint}`);
+    throw youtubeFailureError(result);
   }
 
   return result.data;
@@ -177,7 +389,9 @@ module.exports = {
   showYoutubeHelp,
   parseYoutubeArgs,
   buildYoutubePayload,
+  extractLocalTranscript,
   processYoutube,
+  shouldRetryWithLocalTranscript,
   formatYoutubeResult,
   youtubeCommand,
 };

package/decks/README.md

@@ -0,0 +1,89 @@
+# Deck specs
+
+Build anti-slop Google Slides decks from JSON specs.
+
+## Loop
+
+```text
+notes.md / video  -> atris deck compose   (analysis -> spec, picks layouts)
+spec.json         -> atris deck lint       (cheap pre-check: shape + taste)
+                  -> atris deck build --review (publish + thumbnail fetch)
+                  -> agent reads review.json + PNG thumbnails (or --review-auto)
+                  -> fix spec/engine if needed
+                  -> atris deck review confirm <id> (mark ready + emit receipt)
+```
+
+One-shot: `atris deck video <youtube-url> --review` runs compose -> lint -> build -> review.
+
+## Commands
+
+```bash
+# Compose a spec from a markdown outline (offline) or a video (cloud)
+atris deck compose --md notes.md --out decks/my.json --style narrative
+atris deck compose --url https://youtu.be/VIDEO --out decks/my.json --theme ink
+
+# Pre-build lint (schema shape + taste/clip)
+atris deck lint decks/atris-seed-pitch-v3.json
+
+# Build + open visual review packet (--review-auto also flags blank thumbnails)
+atris deck build decks/atris-seed-pitch-v3.json --title "Atris Seed Pitch v3" --review
+
+# Rebuild an existing deck in place (URL/id stay stable)
+atris deck build decks/atris-seed-pitch-v3.json --update 139zTe9cPOGttzYbW04adRU26VJz0SqWRwaZmkoVibP8
+
+# Batch-build several specs
+atris deck build decks/atris-seed-pitch-v3.json decks/mark-pincus-narrative.json
+
+# One command: video -> reviewed deck
+atris deck video https://youtu.be/VIDEO --theme noir --review
+
+# Re-fetch thumbnails for an existing deck
+atris deck review 139zTe9cPOGttzYbW04adRU26VJz0SqWRwaZmkoVibP8 --spec decks/atris-seed-pitch-v3.json
+
+# After thumbnails pass review (emits a receipt for the action queue)
+atris deck review 139zTe9cPOGttzYbW04adRU26VJz0SqWRwaZmkoVibP8 --confirm "slides 5+8 spacing fixed"
+
+# Builds recorded for a spec
+atris deck history decks/atris-seed-pitch-v3.json
+```
+
+## Themes
+
+| Theme | Vibe | When |
+|-------|------|------|
+| `paper` | warm light cream | default editorial |
+| `terminal` | warm dark brown | wedge / antislop |
+| `ink` | stark white + red accent | press / magazine |
+| `noir` | cool dark + blue accent | podcast / interview |
+
+Pick in spec: `"theme": "noir"`, or override at build: `atris deck build spec.json --theme ink`
+
+List all: `atris deck themes`
+
+## Quality bar
+
+- `build` and `lint` **block on errors**: bad shape (unknown type, missing field), "it is not X, it is Y" copy, or `content-truncated` (more list items than the engine renders)
+- Agent reads every thumbnail before `--confirm` (or `--review-auto` flags blank/failed renders)
+- Stack slides: clean cards, no side accent bars
+- State claims directly; avoid contrast framing ("not taste, it's proof")
+- Prefer narrative types (`interstitial`, `lede`, `prose`, `split`, `bullets`) when content is a story, not a dashboard
+- Lint warns on **template fatigue** (4+ boxed slides: panel, receipt, versus, metricgrid, stack, chips)
+- Dense statement/columns/prose/lede/quote/split text auto-shrinks to stay on-slide
+- `review.json` is the manifest for agents; `receipt.json` is emitted on confirm
+- `slide-01.png` ... `slide-N.png` are the thumbnails to inspect
+
+## Specs
+
+| File | Purpose |
+|------|---------|
+| `atris-seed-pitch-v3.json` | Main investor pitch (10 slides, paper theme) |
+| `atris-one-loop-pitch.json` | Outcome wedge deck (7 slides, terminal theme) |
+| `yash-applied-compute-generalist.json` | Yash Patil / Own or Be Owned (ink, boxed template) |
+| `yash-applied-compute-narrative.json` | Same story, typography-first (ink, no widgets) |
+| `yash-applied-compute-detailed.json` | Full episode notes, 18 slides, bullets + cases |
+| `mark-pincus-sourcery.json` | Mark Pincus / Life at the Speed of Play (noir, boxed) |
+| `mark-pincus-narrative.json` | Same story, box-free narrative (12 slides, noir) |
+| `atris-single-shot-proof.json` | Review loop proof deck (6 slides, single-pass quality bar) |
+| `atris-archetypes-v2.json` | New archetypes showcase (8 slides, paper theme) |
+| `atris-antislop-pitch.json` | 3-slide antislop product pitch |
+| `archetype-catalog.json` | Every slide type once (19 slides, paper theme), design reference for writers |

package/decks/archetype-catalog.json

@@ -0,0 +1,180 @@
+{
+  "theme": "paper",
+  "brand": { "name": "Atris", "accent": "." },
+  "slides": [
+    {
+      "type": "title",
+      "headline": "The deck **archetype** catalog",
+      "sub": "Every slide type Atris renders, shown once, so writers can pick the right one by eye.",
+      "panel": {
+        "header": { "title": "Reference deck", "meta": "19 types" },
+        "rows": [
+          { "title": "Narrative", "sub": "story slides", "value": "7" },
+          { "title": "Structured", "sub": "data slides", "value": "8" },
+          { "title": "Framing", "sub": "open and close", "value": "4" }
+        ],
+        "footer": { "left": "one of each", "right": "paper" }
+      }
+    },
+    {
+      "type": "statement",
+      "text": "Pick the **shape** before you write the words.",
+      "sub": "A statement is one sentence that earns the whole slide. Keep the sub short and it carries the claim."
+    },
+    {
+      "type": "columns",
+      "heading": "When to reach for columns",
+      "columns": [
+        { "h": "Compare", "b": "Set two or three peers side by side so the reader scans the difference fast." },
+        { "h": "Group", "b": "Bucket related ideas under short headers instead of one long paragraph." },
+        { "h": "Balance", "b": "Give each idea equal weight when no single one should win the slide." }
+      ]
+    },
+    {
+      "type": "panel",
+      "heading": "Panel reads like a status board",
+      "sub": "Use it for rows of named items with a value and a state dot. Header and footer are optional.",
+      "panel": {
+        "header": { "title": "Loop health", "meta": "live" },
+        "rows": [
+          { "title": "Plan", "sub": "navigator", "value": "ok", "sev": 0 },
+          { "title": "Build", "sub": "executor", "value": "ok", "active": true },
+          { "title": "Review", "sub": "validator", "value": "queue", "sev": 1 },
+          { "title": "Ship", "sub": "launcher", "value": "hold", "sev": 2 }
+        ],
+        "footer": { "left": "four rows max", "right": "verified" }
+      }
+    },
+    {
+      "type": "chips",
+      "heading": "Chips for a quick taxonomy",
+      "sub": "Drop a row of short labels when the point is breadth, not depth.",
+      "chips": ["title", "statement", "columns", "panel", "timeline", "versus", "receipt", "stack", "quote", "hero"],
+      "mono": "one accent, sentence case, no shouting"
+    },
+    {
+      "type": "bignumber",
+      "number": "19",
+      "label": "slide types in one design system",
+      "sub": "Bignumber exists for the single figure that should land before anything else on the slide."
+    },
+    {
+      "type": "timeline",
+      "heading": "Timeline walks a process",
+      "steps": [
+        { "label": "spec", "sub": "write json" },
+        { "label": "lint", "sub": "cheap check" },
+        { "label": "build", "sub": "publish", "active": true },
+        { "label": "review", "sub": "thumbnails" },
+        { "label": "confirm", "sub": "mark ready" }
+      ],
+      "sub": "Five steps fit cleanly. More than that and the labels start to crowd the edges."
+    },
+    {
+      "type": "versus",
+      "heading": "Versus splits two stances",
+      "left": {
+        "label": "Default slop",
+        "items": ["arial on white", "purple gradients", "em dash everywhere", "five accent colors"]
+      },
+      "right": {
+        "label": "Atris deck",
+        "items": ["committed type", "one warm accent", "sanitized copy", "real data panels"]
+      }
+    },
+    {
+      "type": "metricgrid",
+      "heading": "Metricgrid for four headline figures",
+      "metrics": [
+        { "value": "4", "label": "cards is the cap before the grid gets cramped" },
+        { "value": "2x2", "label": "fixed layout keeps the eye moving in a square" },
+        { "value": "32pt", "label": "value type so the number reads from the back row" },
+        { "value": "1", "label": "accent hue across every card on the slide" }
+      ]
+    },
+    {
+      "type": "receipt",
+      "heading": "Receipt makes a claim auditable",
+      "sub": "Use it when the slide needs evidence fields, not prose. Up to six rows plus a stamp.",
+      "receiptTitle": "catalog build #001",
+      "fields": [
+        { "k": "spec", "v": "archetype-catalog.json" },
+        { "k": "theme", "v": "paper, warm editorial" },
+        { "k": "types", "v": "all 19, one each" },
+        { "k": "lint", "v": "zero errors, zero truncation" },
+        { "k": "use", "v": "design reference for writers" }
+      ],
+      "stamp": "lint clean"
+    },
+    {
+      "type": "stack",
+      "heading": "Stack shows layers in order",
+      "layers": [
+        { "title": "Read the catalog", "sub": "find the type that fits the content" },
+        { "title": "Copy the fields", "sub": "match the names the engine expects" },
+        { "title": "Lint before build", "sub": "catch clips and caps locally" }
+      ],
+      "sub": "Three layers leave room for a closing line beneath the cards."
+    },
+    {
+      "type": "quote",
+      "text": "Write the slide the reader **already wishes** they had.",
+      "author": "Atris deck engine",
+      "role": "design note"
+    },
+    {
+      "type": "hero",
+      "headline": "Hero centers one **big idea**",
+      "sub": "Reach for it when the slide is a moment, not a table. Everything centers under one rule.",
+      "mono": "atris deck build decks/archetype-catalog.json --review",
+      "footer": "atris.ai · archetype catalog · 2026"
+    },
+    {
+      "type": "interstitial",
+      "kicker": "section break",
+      "text": "Now the **narrative** types",
+      "sub": "Interstitial is a chapter card. Big type, lots of air, a kicker to mark the turn."
+    },
+    {
+      "type": "lede",
+      "headline": "Lede opens like a feature story",
+      "dek": "A magazine intro slide: one strong headline, a deck of supporting text, and a byline that grounds it.",
+      "byline": "atris-cli · deck-compose · paper theme"
+    },
+    {
+      "type": "prose",
+      "heading": "Prose is for paragraphs",
+      "paragraphs": [
+        "When the content is genuinely a few sentences of argument, do not force it into cards. Prose gives the reader room to follow a line of thought without a widget in the way.",
+        "The engine fits one font size across every paragraph and floats them down to the slide floor, so two or three short paragraphs stay readable and balanced."
+      ]
+    },
+    {
+      "type": "split",
+      "heading": "Split pairs text with one figure",
+      "body": "Put the explanation on the left and let a single number or short phrase carry the right side. It reads as claim plus proof without a full panel.",
+      "accent": "60%",
+      "accentSub": "of the slide is text; the accent is the punchline the reader remembers."
+    },
+    {
+      "type": "bullets",
+      "heading": "Bullets, done with restraint",
+      "items": [
+        { "text": "Keep it to seven or fewer", "sub": "the engine shrinks type as the list grows" },
+        { "text": "Lead each item with a verb or a noun", "sub": "not a full sentence" },
+        { "text": "Add a sub only when it earns its line", "sub": "optional second tier per item" },
+        { "text": "Prefer a real list over a wall of cards", "sub": "typography, not boxes" }
+      ],
+      "sub": "A true bullet list: accent dot, text, no card around each line."
+    },
+    {
+      "type": "close",
+      "tagline": "One design system, nineteen ways to say it well.",
+      "buttons": [
+        { "label": "Read the engine", "primary": true },
+        { "label": "Lint your spec" }
+      ],
+      "footer": "atris.ai · archetype catalog · 2026"
+    }
+  ]
+}