atris 3.30.8 → 3.31.0

package/lib/pulse.js

@@ -85,6 +85,21 @@ function buildPulseScorecardRow(input = {}) {
   };
 }
 
+function buildInterruptedPulseReceipt(input = {}) {
+  const signal = input.signal || 'signal';
+  return buildPulseReceipt({
+    tickIndex: input.tickIndex,
+    phase: 'finished',
+    actor: 'pulse_signal',
+    actorOk: false,
+    actorReason: String(signal).toLowerCase(),
+    what: `tick interrupted by ${signal}`,
+    elapsedMs: input.startedAt ? Date.now() - input.startedAt : input.elapsedMs,
+    prevTickStale: input.prevTickStale,
+    reward: -1,
+  });
+}
+
 // The heartbeat's full composition (mirrors the /loop skill): run the due
 // mission to continue an existing goal; if none is due, fall back to an
 // autopilot tick — that path is where proposeCandidateHorizons AUTHORS a new
@@ -198,6 +213,61 @@ function shellSingleQuote(value) {
   return `'${String(value || '').replace(/'/g, "'\\''")}'`;
 }
 
+function normalizeCronCadence(value = DEFAULT_CADENCE_CRON) {
+  const raw = String(value || DEFAULT_CADENCE_CRON).trim();
+  if (!raw) return DEFAULT_CADENCE_CRON;
+  if (raw.toLowerCase() === 'hourly') return DEFAULT_CADENCE_CRON;
+  if (raw.toLowerCase() === 'daily') return '23 2 * * *';
+  if (raw.split(/\s+/).length === 5) return raw;
+
+  const minutes = raw.match(/^(\d+)\s*(m|min|mins|minute|minutes)$/i);
+  if (minutes) {
+    const n = Number(minutes[1]);
+    if (Number.isInteger(n) && n >= 1 && n <= 59) return `*/${n} * * * *`;
+    throw new Error(`invalid cadence "${raw}": minute cadence must be 1m-59m or a 5-field cron`);
+  }
+
+  const hours = raw.match(/^(\d+)\s*(h|hr|hrs|hour|hours)$/i);
+  if (hours) {
+    const n = Number(hours[1]);
+    if (Number.isInteger(n) && n >= 1 && n <= 23) return `23 */${n} * * *`;
+    if (n === 24) return '23 0 * * *';
+    throw new Error(`invalid cadence "${raw}": hour cadence must be 1h-24h or a 5-field cron`);
+  }
+
+  throw new Error(`invalid cadence "${raw}": use 13m, 2h, hourly, daily, or a 5-field cron`);
+}
+
+function normalizeExpiryDuration(input = {}) {
+  const hasHours = input.hours !== undefined && input.hours !== null && String(input.hours).trim() !== '';
+  if (hasHours) {
+    const hours = Number(input.hours);
+    if (Number.isFinite(hours) && hours > 0) {
+      return {
+        source: 'hours',
+        hours,
+        days: null,
+        seconds: Math.ceil(hours * 60 * 60),
+      };
+    }
+    throw new Error(`invalid hours "${input.hours}": use a positive number of hours`);
+  }
+
+  const rawDays = input.days === undefined || input.days === null || String(input.days).trim() === ''
+    ? 7
+    : input.days;
+  const days = Number(rawDays);
+  if (Number.isFinite(days) && days > 0) {
+    return {
+      source: 'days',
+      hours: null,
+      days,
+      seconds: Math.ceil(days * 24 * 60 * 60),
+    };
+  }
+  throw new Error(`invalid days "${rawDays}": use a positive number of days`);
+}
+
 function runnerEnvAliasExport({ genericName, legacyName, value }) {
   if (!value) return '';
   return [
@@ -365,7 +435,7 @@ echo "done: $(date -Iseconds) exit=$?" >> "$log"
 function buildCrontabLine(opts = {}) {
   const { cron = DEFAULT_CADENCE_CRON, scriptPath, marker = PULSE_MARKER } = opts;
   if (!scriptPath) throw new Error('buildCrontabLine: scriptPath is required');
-  return `${cron} ${scriptPath} # ${marker}`;
+  return `${normalizeCronCadence(cron)} ${scriptPath} # ${marker}`;
 }
 
 module.exports = {
@@ -382,7 +452,9 @@ module.exports = {
   pulseLockDir,
   buildPulseReceipt,
   buildPulseScorecardRow,
+  buildInterruptedPulseReceipt,
   scoreTick,
+  normalizeExpiryDuration,
   shouldWriteScorecard,
   shouldFallbackToAutopilot,
   findOrphanStarts,
@@ -398,4 +470,5 @@ module.exports = {
   releaseLock,
   buildTickScript,
   buildCrontabLine,
+  normalizeCronCadence,
 };

package/lib/runner-command.js

@@ -3,14 +3,12 @@
 // Shared worker-spawn builder for the autonomous loops (missions, autopilot, run).
 //
 // Autonomous ticks must target a LIVE model. Inheriting the CLI's persisted
-// selection is fragile: a *versioned* id (e.g. claude-fable-5) silently dies
-// when that version is retired, and every tick then errors as a generic
-// 'claude-error' with no clue why (lesson: retired-model-kills-loop-silently,
-// CLI-245). Precedence: explicit model -> ATRIS_RUNNER_MODEL env ->
-// ATRIS_RUNNER_PROFILE -> legacy ATRIS_CLAUDE_MODEL env -> 'opus' alias. The
-// CLI resolves aliases to the latest live model, so an alias never retires out
-// from under the loop.
-const DEFAULT_CLAUDE_RUNNER_MODEL = 'opus';
+// selection is fragile: the local Claude Code `opus` alias can resolve to
+// different Opus releases across machines and account rollouts. Pin the default
+// so autonomous runs are reproducible, while keeping explicit per-run/env knobs
+// first in precedence. Precedence: explicit model -> ATRIS_RUNNER_MODEL env ->
+// ATRIS_RUNNER_PROFILE -> legacy ATRIS_CLAUDE_MODEL env -> pinned default.
+const DEFAULT_CLAUDE_RUNNER_MODEL = 'claude-opus-4-8';
 const DEFAULT_CLAUDE_RUNNER_BIN = 'claude';
 const RUNNER_PROFILES = Object.freeze({
   'atris-fast': Object.freeze({
@@ -97,6 +95,19 @@ function buildRunnerAvailabilityCommand() {
   return `command -v ${shellWord(resolveClaudeRunnerBin())}`;
 }
 
+function runnerAvailabilityFailureMessage(error) {
+  const message = error && error.message ? String(error.message).trim() : '';
+  if (message.startsWith('Unknown ATRIS_RUNNER_PROFILE')) {
+    return `${message}. Set ATRIS_RUNNER_PROFILE to one of: ${Object.keys(RUNNER_PROFILES).join(', ')}.`;
+  }
+
+  let runnerBin = 'configured runner';
+  try {
+    runnerBin = resolveClaudeRunnerBin();
+  } catch {}
+  return `${runnerBin} CLI not found. Set ATRIS_RUNNER_BIN (or legacy ATRIS_CLAUDE_BIN), or install the configured runner first.`;
+}
+
 function renderRunnerCommandTemplate(template, { promptFile, allowedTools, model }) {
   const allowedToolsFlag = allowedTools ? `--allowedTools ${shellWord(allowedTools)}` : '';
   const promptFileWord = shellWord(promptFile);
@@ -152,5 +163,6 @@ module.exports = {
   resolveClaudeRunnerBin,
   resolveClaudeRunnerCommandTemplate,
   buildRunnerAvailabilityCommand,
+  runnerAvailabilityFailureMessage,
   buildRunnerCommand,
 };

package/lib/runs-prune.js

@@ -0,0 +1,242 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function stampIso() {
+  return new Date().toISOString();
+}
+
+function toPosixPath(value) {
+  return String(value || '').split(path.sep).join('/');
+}
+
+function fileSize(filePath) {
+  try {
+    return fs.statSync(filePath).size;
+  } catch {
+    return 0;
+  }
+}
+
+function listFiles(dir) {
+  const out = [];
+  function visit(current) {
+    let entries = [];
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === '_archive') continue;
+        visit(fullPath);
+        continue;
+      }
+      if (entry.isFile()) out.push(fullPath);
+    }
+  }
+  visit(dir);
+  return out;
+}
+
+function runPathReferences(root) {
+  const stateDir = path.join(root, '.atris', 'state');
+  const refs = new Set();
+  const pattern = /atris\/runs\/[A-Za-z0-9._~:/@%+=,-]+(?:\/[A-Za-z0-9._~:@%+=,-]+)*/g;
+  const scan = (filePath) => {
+    let text = '';
+    try {
+      text = fs.readFileSync(filePath, 'utf8');
+    } catch {
+      return;
+    }
+    for (const match of text.matchAll(pattern)) {
+      refs.add(match[0].replace(/[)"'`.,;]+$/g, ''));
+    }
+  };
+  if (fs.existsSync(stateDir)) {
+    for (const filePath of listFiles(stateDir)) scan(filePath);
+  }
+  return refs;
+}
+
+function referencedDirs(refs) {
+  const dirs = new Set();
+  for (const ref of refs) {
+    const dir = path.posix.dirname(ref);
+    if (dir && dir !== '.' && dir !== 'atris/runs') dirs.add(dir);
+  }
+  return dirs;
+}
+
+function runEntry(root, filePath, refs, refDirs, nowMs) {
+  const rel = toPosixPath(path.relative(root, filePath));
+  let stat = null;
+  try {
+    stat = fs.statSync(filePath);
+  } catch {
+    return null;
+  }
+  const dir = path.posix.dirname(rel);
+  const referenced = refs.has(rel) || refDirs.has(dir);
+  return {
+    path: rel,
+    absolute_path: filePath,
+    bytes: stat.size,
+    mtime_ms: stat.mtimeMs,
+    age_days: Math.max(0, Math.floor((nowMs - stat.mtimeMs) / 86400000)),
+    referenced,
+    kind: path.extname(filePath).toLowerCase().replace(/^\./, '') || 'file',
+  };
+}
+
+function compactJsonReceipt(filePath) {
+  let parsed = null;
+  try {
+    parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+  return {
+    schema: parsed.schema || null,
+    mission_id: parsed.mission_id || parsed.mission?.id || null,
+    objective: parsed.objective || parsed.mission?.objective || null,
+    owner: parsed.owner || parsed.mission?.owner || null,
+    at: parsed.at || parsed.generated_at || parsed.created_at || null,
+    verifier: parsed.verifier || parsed.result?.verifier_result?.command || null,
+    passed: parsed.result?.passed === true || parsed.result?.verifier_result?.passed === true || null,
+    kind: parsed.result?.kind || parsed.action || null,
+    summary: parsed.result?.tick?.summary || parsed.result?.summary || parsed.landing?.happened || null,
+  };
+}
+
+function removeEmptyDirs(dir, stopDir) {
+  let current = dir;
+  while (current && current.startsWith(stopDir) && current !== stopDir) {
+    try {
+      const entries = fs.readdirSync(current);
+      if (entries.length) break;
+      fs.rmdirSync(current);
+    } catch {
+      break;
+    }
+    current = path.dirname(current);
+  }
+}
+
+function pruneRuns(root = process.cwd(), options = {}) {
+  const runsDir = options.runsDir || path.join(root, 'atris', 'runs');
+  const apply = options.apply === true;
+  const archive = options.archive !== false;
+  const keepNewest = Number.isFinite(options.keepNewest) ? Math.max(0, Math.floor(options.keepNewest)) : 200;
+  const keepDays = Number.isFinite(options.keepDays) ? Math.max(0, Math.floor(options.keepDays)) : 14;
+  const nowMs = options.nowMs || Date.now();
+  const cutoffMs = nowMs - keepDays * 86400000;
+  const refs = runPathReferences(root);
+  const refDirs = referencedDirs(refs);
+  const files = fs.existsSync(runsDir)
+    ? listFiles(runsDir).map((filePath) => runEntry(root, filePath, refs, refDirs, nowMs)).filter(Boolean)
+    : [];
+  const newest = new Set(
+    files
+      .slice()
+      .sort((a, b) => b.mtime_ms - a.mtime_ms || a.path.localeCompare(b.path))
+      .slice(0, keepNewest)
+      .map((entry) => entry.path),
+  );
+  const totalBytes = files.reduce((sum, entry) => sum + entry.bytes, 0);
+  const decisions = files.map((entry) => {
+    const reasons = [];
+    if (entry.referenced) reasons.push('referenced');
+    if (newest.has(entry.path)) reasons.push('newest');
+    if (entry.mtime_ms >= cutoffMs) reasons.push('recent');
+    const prune = reasons.length === 0;
+    return { ...entry, prune, keep_reasons: reasons };
+  });
+  const candidates = decisions.filter((entry) => entry.prune);
+  const archiveEntries = archive
+    ? candidates.map((entry) => ({
+      path: entry.path,
+      bytes: entry.bytes,
+      age_days: entry.age_days,
+      compact: entry.kind === 'json' ? compactJsonReceipt(entry.absolute_path) : null,
+    }))
+    : [];
+  let manifestPath = null;
+  const deleted = [];
+  const errors = [];
+  if (apply && candidates.length) {
+    const archiveDir = path.join(runsDir, '_archive');
+    if (archive) {
+      fs.mkdirSync(archiveDir, { recursive: true });
+      manifestPath = path.join(archiveDir, `prune-${stampIso().replace(/[:.]/g, '-')}.json`);
+      fs.writeFileSync(manifestPath, JSON.stringify({
+        schema: 'atris.runs_prune_manifest.v1',
+        generated_at: stampIso(),
+        policy: { keep_newest: keepNewest, keep_days: keepDays },
+        pruned_count: candidates.length,
+        pruned_bytes: candidates.reduce((sum, entry) => sum + entry.bytes, 0),
+        entries: archiveEntries,
+      }, null, 2) + '\n', 'utf8');
+    }
+    for (const entry of candidates) {
+      try {
+        fs.unlinkSync(entry.absolute_path);
+        deleted.push(entry.path);
+        removeEmptyDirs(path.dirname(entry.absolute_path), runsDir);
+      } catch (error) {
+        errors.push({ path: entry.path, error: error.message || String(error) });
+      }
+    }
+  }
+  return {
+    schema: 'atris.runs_prune_preview.v1',
+    action: apply ? 'runs_pruned' : 'runs_prune_preview',
+    runs_dir: toPosixPath(path.relative(root, runsDir)) || 'atris/runs',
+    applied: apply,
+    policy: { keep_newest: keepNewest, keep_days: keepDays, archive },
+    total_files: files.length,
+    total_bytes: totalBytes,
+    referenced_files: decisions.filter((entry) => entry.keep_reasons.includes('referenced')).length,
+    recent_files: decisions.filter((entry) => entry.keep_reasons.includes('recent')).length,
+    newest_files: decisions.filter((entry) => entry.keep_reasons.includes('newest')).length,
+    prune_count: candidates.length,
+    prune_bytes: candidates.reduce((sum, entry) => sum + entry.bytes, 0),
+    deleted_count: deleted.length,
+    manifest_path: manifestPath ? toPosixPath(path.relative(root, manifestPath)) : null,
+    candidates: candidates.map((entry) => ({
+      path: entry.path,
+      bytes: entry.bytes,
+      age_days: entry.age_days,
+      kind: entry.kind,
+    })),
+    deleted,
+    errors,
+  };
+}
+
+function formatBytes(bytes) {
+  const value = Number(bytes || 0);
+  if (value < 1024) return `${value} B`;
+  if (value < 1024 * 1024) return `${(value / 1024).toFixed(1)} KB`;
+  return `${(value / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+function runsPruneLines(result) {
+  return [
+    'Landing:',
+    `  Changed: ${result.applied ? `Pruned ${result.deleted_count} old run file(s).` : `Found ${result.prune_count} old run file(s) eligible for pruning.`}`,
+    `  How I checked: Scanned ${result.total_files} files in ${result.runs_dir}; kept referenced, newest, and recent proof.`,
+    `  Proof: ${result.applied ? (result.manifest_path ? `Manifest saved at ${result.manifest_path}.` : 'No manifest was needed.') : `Would reclaim ${formatBytes(result.prune_bytes)}.`}`,
+    `  Next: ${result.applied ? 'Run this command on a heartbeat when the run folder grows again.' : 'Run again with --apply to delete the eligible old files.'}`,
+  ];
+}
+
+module.exports = {
+  pruneRuns,
+  runsPruneLines,
+  formatBytes,
+};

package/lib/task-proof.js

@@ -2,7 +2,7 @@
 
 const GENERIC_COMPLETION_PROOF_RE = /^(?:done|done now|complete|completed|finished|fixed|handled|ship|shipped|ok|okay|yes|yep|looks good|looks good to me|all set|should be good|works now|approved|approve|lgtm|failed)$/i;
 
-const COMMAND_PROOF_RE = /\b(?:npm\s+run|npm\s+test|node\s+--test|node\s+scripts\/|pnpm\b|yarn\b|npx\b|pytest\b|python\s+-m|tsc\b|vite\s+build|git\s+diff\s+--(?:check|exit-code|quiet)|grep\s+-[A-Za-z]*q[A-Za-z]*|rg\s+(?:-\S+\s+)*(?:"[^"]+"|'[^']+'|\S+)\s+(?:\.{0,2}\/|~\/|\/|[\w.-]+\/|[\w.-]+\.[A-Za-z0-9]|\b(?:atris|bin|commands|lib|scripts|src|test)\b)|diff\s+(?:-u|--brief)|cmp\s+-s|curl\b|atris\s+task|\.\/ax\b|ax\s+--|test\s+-s)\b/i;
+const COMMAND_PROOF_RE = /\b(?:npm\s+run|npm\s+test|node\s+--test|node\s+scripts\/|node\s+bin\/atris[.]js\s+clean\s+--dry-run\s+--json|pnpm\b|yarn\b|npx\b|pytest\b|python\s+-m|tsc\b|vite\s+build|git\s+diff\s+--(?:check|exit-code|quiet)|grep\s+-[A-Za-z]*q[A-Za-z]*|rg\s+(?:-\S+\s+)*(?:"[^"]+"|'[^']+'|\S+)\s+(?:\.{0,2}\/|~\/|\/|[\w.-]+\/|[\w.-]+\.[A-Za-z0-9]|\b(?:atris|bin|commands|lib|scripts|src|test)\b)|diff\s+(?:-u|--brief)|cmp\s+-s|curl\b|atris\s+task|\.\/ax\b|ax\s+--|test\s+-s)\b/i;
 const FILE_PROOF_RE = /(?:^|[\s'"`])(?:\.{0,2}\/|~\/|\/Users\/|src\/|scripts\/|atris\/|backend\/|public\/|resources\/|package[.]json|main[.]js|preload[.]js|AGENTXP_PROOF[.]md)[^\s'"`,;)]*/i;
 const PATH_ONLY_PROOF_RE = /(?:^|[\s'"`])(?:\.{0,2}\/|~\/|\/Users\/|\/private\/|\/var\/|atris\/runs\/|\.atris\/state\/)[^\s'"`,;)]+(?:[.](?:json|jsonl|md|log|txt|png|jpg|jpeg|pdf))?/i;
 const RECEIPT_OR_ARTIFACT_RE = /\b(?:receipt|artifact|screenshot|log|trace|path=|file=|bytes=|model=|opened=|https?:\/\/)\b/i;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.30.8",
+  "version": "3.31.0",
   "main": "bin/atris.js",
   "bin": {
     "atris": "bin/atris.js",
@@ -17,10 +17,10 @@
     "templates/",
     "README.md",
     "AGENTS.md",
+    "FOR_AGENTS.md",
     "atris.md",
     "GETTING_STARTED.md",
     "PERSONA.md",
-    "atris/atrisDev.md",
     "atris/CLAUDE.md",
     "atris/GEMINI.md",
     "atris/GETTING_STARTED.md",
@@ -48,12 +48,12 @@
     "atris/team/_template/MEMBER.md",
     "atris/features/_templates/",
     "atris/features/company-brain-sync/",
-    "templates/",
     "atris/policies/",
     "atris/skills/"
   ],
   "scripts": {
     "test": "node --test",
+    "lint:decks": "node scripts/lint-all-decks.js",
     "publish:release": "node scripts/publish-atris-release.js",
     "prepare": "cp scripts/pre-commit .git/hooks/pre-commit 2>/dev/null && chmod +x .git/hooks/pre-commit || true"
   },

package/decks/atris-seed-pitch-v3.json

@@ -1,118 +0,0 @@
-{
-  "theme": "paper",
-  "brand": { "name": "Atris", "accent": "." },
-  "slides": [
-    {
-      "type": "title",
-      "headline": "The self-improving **business computer.**",
-      "sub": "Work closes its own loop. Memory, authority, receipts, outcomes. One standard for humans and agents.",
-      "panel": {
-        "header": { "title": "Closed loop", "meta": "every action" },
-        "rows": [
-          { "title": "context", "sub": "memory in", "value": "1", "valueSub": "step", "sev": 2 },
-          { "title": "action", "sub": "member acts", "value": "2", "valueSub": "step", "sev": 1 },
-          { "title": "receipt", "sub": "proof out", "value": "3", "valueSub": "step", "sev": 0, "active": true },
-          { "title": "outcome", "sub": "result", "value": "4", "valueSub": "step", "sev": 2 }
-        ],
-        "footer": { "left": "environment first", "right": "model later" }
-      }
-    },
-    {
-      "type": "statement",
-      "text": "Work used to **end.** Now every action can become memory.",
-      "sub": "Stored work becomes acted work, then remembered work. Context, action, receipt, outcome, reward, better next action."
-    },
-    {
-      "type": "columns",
-      "heading": "A business computer, not a chatbot",
-      "columns": [
-        {
-          "h": "Memory",
-          "b": "Receipts compress into lessons and return as minimum useful context."
-        },
-        {
-          "h": "Members",
-          "b": "Humans and agents with owner, tools, authority, trail, and score."
-        },
-        {
-          "h": "Receipts",
-          "b": "Who authorized, who acted, what proof confirms it, what the business got."
-        }
-      ]
-    },
-    {
-      "type": "statement",
-      "text": "They learn the **click.** We learn the outcome.",
-      "sub": "Others reward the draft interaction. Atris rewards the business result: reply, booking, deal, recovery."
-    },
-    {
-      "type": "panel",
-      "heading": "The market proved the gap.",
-      "sub": "Agents act everywhere. Almost none verify the result.",
-      "panel": {
-        "header": { "title": "Why now", "meta": "2026" },
-        "rows": [
-          { "title": "No verification", "sub": "AIRQ audit", "value": "98%", "valueSub": "of agents", "sev": 0, "active": true },
-          { "title": "Self-grader cheats", "sub": "Reward benchmark", "value": "14%", "valueSub": "top models", "sev": 0 },
-          { "title": "Agent rollback", "sub": "Sinch survey", "value": "74%", "valueSub": "enterprises", "sev": 1 }
-        ],
-        "footer": { "left": "guardrails gate behavior", "right": "not results" }
-      }
-    },
-    {
-      "type": "columns",
-      "heading": "Product today",
-      "columns": [
-        {
-          "h": "Atris2 Fast",
-          "b": "Open tool harness. Periphery prepares work without usurping judgment."
-        },
-        {
-          "h": "Deferral queue",
-          "b": "Sends, money, and public acts pause for your approval with a judgment packet."
-        },
-        {
-          "h": "Antislop gates",
-          "b": "Deterministic block on AI UI tells, hype copy, and raw outbound artifacts."
-        }
-      ]
-    },
-    {
-      "type": "bignumber",
-      "number": "+3.35",
-      "label": "RL readiness lift after verified episodes",
-      "sub": "Diff, receipt, verifier, outcome. Atris runs on Atris."
-    },
-    {
-      "type": "panel",
-      "heading": "Customer recovery first.",
-      "sub": "Close one painful loop. Prove the outcome. Expand.",
-      "panel": {
-        "header": { "title": "Wedge", "meta": "expand" },
-        "rows": [
-          { "title": "Customer silent", "sub": "churn or complaint", "value": "in", "sev": 1 },
-          { "title": "Member acts", "sub": "draft recovery", "value": "act", "sev": 0, "active": true },
-          { "title": "Receipt", "sub": "trust or revenue?", "value": "proof", "sev": 2 },
-          { "title": "Expand", "sub": "sales, ops, finance", "value": "out", "sev": 1 }
-        ],
-        "footer": { "left": "one loop proven", "right": "then expand" }
-      }
-    },
-    {
-      "type": "chips",
-      "heading": "Business model",
-      "sub": "We do not tax Members. Members close loops.",
-      "chips": ["$200/mo computer", "Unlimited Members", "Usage credits", "Managed setup", "Enterprise"],
-      "mono": "base + verified outcomes"
-    },
-    {
-      "type": "close",
-      "tagline": "Ambition and freedom should not cancel each other out.",
-      "buttons": [
-        { "label": "See the demo", "primary": true },
-        { "label": "Talk to us" }
-      ],
-      "footer": "Raising $10M seed · atris.ai · 2026"
-    }
-  ]
-}

package/decks/atris-seed-pitch-v4-skeleton.json

@@ -1,106 +0,0 @@
-{
-  "theme": "paper",
-  "brand": { "name": "Atris", "accent": "." },
-  "slides": [
-    {
-      "type": "columns",
-      "heading": "1 · The gate",
-      "sub": "Models regulated, access unequal, AI narrative toxic.",
-      "columns": [
-        { "h": "bullet 1", "b": "(your words)" },
-        { "h": "bullet 2", "b": "(your words)" },
-        { "h": "bullet 3", "b": "(your words)" }
-      ]
-    },
-    {
-      "type": "columns",
-      "heading": "2 · The trap",
-      "sub": "Everyone is building the same mimetic slop on rented intelligence.",
-      "columns": [
-        { "h": "bullet 1", "b": "(your words)" },
-        { "h": "bullet 2", "b": "(your words)" },
-        { "h": "bullet 3", "b": "(your words)" }
-      ]
-    },
-    {
-      "type": "columns",
-      "heading": "3 · The shift",
-      "sub": "Early adopters want an owned center, not another chatbot.",
-      "columns": [
-        { "h": "bullet 1", "b": "(your words)" },
-        { "h": "bullet 2", "b": "(your words)" },
-        { "h": "bullet 3", "b": "(your words)" }
-      ]
-    },
-    {
-      "type": "columns",
-      "heading": "4 · The sovereign individual",
-      "sub": "At the center. Ecosystem around them — software, school, community, capital.",
-      "columns": [
-        { "h": "bullet 1", "b": "(your words)" },
-        { "h": "bullet 2", "b": "(your words)" },
-        { "h": "bullet 3", "b": "(your words)" }
-      ]
-    },
-    {
-      "type": "columns",
-      "heading": "5 · The product",
-      "sub": "Self-improving environment, swappable models, agent-native system of record.",
-      "columns": [
-        { "h": "bullet 1", "b": "(your words)" },
-        { "h": "bullet 2", "b": "(your words)" },
-        { "h": "bullet 3", "b": "(your words)" }
-      ]
-    },
-    {
-      "type": "columns",
-      "heading": "6 · The proof",
-      "sub": "Center Study and businesses that improve overnight. Live loops, not demos.",
-      "columns": [
-        { "h": "bullet 1", "b": "(your words)" },
-        { "h": "bullet 2", "b": "(your words)" },
-        { "h": "bullet 3", "b": "(your words)" }
-      ]
-    },
-    {
-      "type": "columns",
-      "heading": "7 · First business",
-      "sub": "Education / transformation. ~$250k run rate. 1–3 FDEs per cluster.",
-      "columns": [
-        { "h": "bullet 1", "b": "(your words)" },
-        { "h": "bullet 2", "b": "(your words)" },
-        { "h": "bullet 3", "b": "(your words)" }
-      ]
-    },
-    {
-      "type": "columns",
-      "heading": "8 · Customers",
-      "sub": "DoorDash and Pallet — what actually runs today.",
-      "columns": [
-        { "h": "bullet 1", "b": "(your words)" },
-        { "h": "bullet 2", "b": "(your words)" },
-        { "h": "bullet 3", "b": "(your words)" }
-      ]
-    },
-    {
-      "type": "columns",
-      "heading": "9 · Growth",
-      "sub": "Founder-first distribution. Mimetic spread. Clone the machine.",
-      "columns": [
-        { "h": "bullet 1", "b": "(your words)" },
-        { "h": "bullet 2", "b": "(your words)" },
-        { "h": "bullet 3", "b": "(your words)" }
-      ]
-    },
-    {
-      "type": "columns",
-      "heading": "10 · The ask",
-      "sub": "$10M — FDE team, narrative, run more businesses, own the layer beneath the gate.",
-      "columns": [
-        { "h": "bullet 1", "b": "(your words)" },
-        { "h": "bullet 2", "b": "(your words)" },
-        { "h": "bullet 3", "b": "(your words)" }
-      ]
-    }
-  ]
-}