atris 3.30.12 → 3.32.0

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-db.js

@@ -1198,7 +1198,7 @@ function chatTask(db, { id, actor, content, goal, summary }) {
   };
 }
 
-function reviewTask(db, { id, actor, reward, lesson, nextTask, proof, verify, careerXpEligible = false, clearedFields = [] }) {
+function reviewTask(db, { id, actor, reward, lesson, nextTask, proof, verify, careerXpEligible = false, clearedFields = [], landing = {} }) {
   if (!id) throw new Error('id required');
   const row = getTask(db, id);
   if (!row) return { reviewed: false, reason: 'not_found' };
@@ -1213,6 +1213,15 @@ function reviewTask(db, { id, actor, reward, lesson, nextTask, proof, verify, ca
   const clearedReviewFields = Array.isArray(clearedFields)
     ? Array.from(new Set(clearedFields.filter(field => field === 'lesson' || field === 'next_task')))
     : [];
+  const landingInput = landing && typeof landing === 'object' ? landing : {};
+  let landingUpdated = false;
+  for (const key of ['happened', 'checked', 'tested', 'decision']) {
+    const cleaned = cleanLandingText(landingInput[key]);
+    if (cleaned) {
+      metadata[`landing_${key}`] = cleaned;
+      landingUpdated = true;
+    }
+  }
   const reviewingPendingProof = row.status === 'review'
     && metadata.approval_status === 'pending'
     && numericReward <= 0
@@ -1250,7 +1259,7 @@ function reviewTask(db, { id, actor, reward, lesson, nextTask, proof, verify, ca
     metadata.accepted_at = new Date().toISOString();
     metadata.accepted_by = reviewer;
   }
-  if (reviewingPendingProof || updatingPendingReviewProof || (numericReward > 0 && row.status === 'done')) {
+  if (reviewingPendingProof || updatingPendingReviewProof || (numericReward > 0 && row.status === 'done') || landingUpdated) {
     withBusyRetry(() => db.prepare(`
       UPDATE tasks
          SET metadata = ?,
@@ -1271,6 +1280,14 @@ function reviewTask(db, { id, actor, reward, lesson, nextTask, proof, verify, ca
     payload.agent_certified = metadata.agent_certified === true;
     payload.agent_certification_policy = metadata.agent_certification_policy || null;
   }
+  if (landingUpdated) {
+    payload.landing = {
+      happened: metadata.landing_happened || null,
+      checked: metadata.landing_checked || null,
+      tested: metadata.landing_tested || null,
+      decision: metadata.landing_decision || null,
+    };
+  }
   if (clearedReviewFields.length) payload.cleared_review_fields = clearedReviewFields;
   const event = appendTaskEvent(db, {
     taskId: id,

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.12",
+  "version": "3.32.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,14 +48,14 @@
     "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"
+    "prepare": "cp scripts/pre-commit .git/hooks/pre-commit 2>/dev/null && cp scripts/commit-msg .git/hooks/commit-msg 2>/dev/null && cp scripts/prepare-commit-msg .git/hooks/prepare-commit-msg 2>/dev/null && chmod +x .git/hooks/pre-commit .git/hooks/commit-msg .git/hooks/prepare-commit-msg || true"
   },
   "keywords": [
     "atrisdev",

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)" }
-      ]
-    }
-  ]
-}

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

@@ -1,109 +0,0 @@
-{
-  "theme": "paper",
-  "brand": { "name": "Atris", "accent": "." },
-  "slides": [
-    {
-      "type": "title",
-      "headline": "Every business owner has two real problems.",
-      "sub": "The work they hate doing. The work they can't afford to hire for. Atris does both — inside their company, with a receipt every time.",
-      "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": "perimeter-resident", "right": "outcome-graded" }
-      }
-    },
-    {
-      "type": "columns",
-      "heading": "Three operators. Three jobs. One product.",
-      "columns": [
-        {
-          "h": "DoorDash",
-          "b": "Forecasting, weekly business review, internal Atris adoption. The workflow became a process. The process became a religion."
-        },
-        {
-          "h": "Pallet",
-          "b": "Recruiting team. Atris learns the non-engineering workflow and converts it to a coding problem."
-        },
-        {
-          "h": "[Customer 3]",
-          "b": "Bookkeeping or finance ops. Hours of human grunt work compressed to minutes, with a receipt per close."
-        }
-      ]
-    },
-    {
-      "type": "bignumber",
-      "number": "$250k",
-      "label": "run rate · 1–3 FDEs · operator workflows at $10M–$5B companies",
-      "sub": "We start in the room nobody else is in. Then ten more rooms exactly like it."
-    },
-    {
-      "type": "statement",
-      "text": "They store **facts.** We learn the **outcome.**",
-      "sub": "Mem0 stores facts. Letta stores context. Glean indexes docs. Atris is the only one where the customer's runtime ships back a reward signal so the agent gets measurably better at their work — with the data never leaving their perimeter."
-    },
-    {
-      "type": "panel",
-      "heading": "One machine, N customers.",
-      "sub": "Each with their own disk, own behavior, own reward signal. Same code everywhere. No data crosses.",
-      "panel": {
-        "header": { "title": "Architecture", "meta": "perimeter-resident" },
-        "rows": [
-          { "title": "Disk", "sub": "per-customer memory", "value": "in", "valueSub": "perimeter", "sev": 1 },
-          { "title": "Behavior", "sub": "per-customer policies", "value": "in", "valueSub": "perimeter", "sev": 1 },
-          { "title": "Reward signal", "sub": "verifiable outcomes", "value": "out", "valueSub": "to us", "sev": 0, "active": true },
-          { "title": "Weights", "sub": "trained on reward stream", "value": "back", "valueSub": "each release", "sev": 2 }
-        ],
-        "footer": { "left": "data plane stays", "right": "reward plane streams" }
-      }
-    },
-    {
-      "type": "statement",
-      "text": "The labs are becoming the new **oil companies.**",
-      "sub": "Frontier models are being rate-limited, regulated, gated customer-by-customer. Standard Oil didn't lose to a better well — it lost to the refinery. The next trillion-dollar company owns the layer between raw intelligence and the work."
-    },
-    {
-      "type": "columns",
-      "heading": "Why now",
-      "columns": [
-        {
-          "h": "Labs gated",
-          "b": "Tokens regulated. Frontier access limited. Customer-by-customer approval. The race for the smartest brain is becoming a utility."
-        },
-        {
-          "h": "Wrappers dead",
-          "b": "Thin GPT wrappers are over. What's alive is the layer beneath — memory, taste, approval, proof, on the customer's perimeter."
-        },
-        {
-          "h": "Window open",
-          "b": "Installation phase. History says the next decade's winners are not the rail-layers. Amazon over Cisco. Google over WorldCom. Walmart over the railroads."
-        }
-      ]
-    },
-    {
-      "type": "statement",
-      "text": "The **Shadow Center.**",
-      "sub": "Every system has a center. The labs occupy the one beneath every AI-native business today. The seat is open. Atris is the architecture for the next occupant — memory, taste, approval, proof, running inside the customer's perimeter, getting sharper every week."
-    },
-    {
-      "type": "chips",
-      "heading": "Business model",
-      "sub": "Base + services + outcomes. We do not tax Members.",
-      "chips": ["$200/mo computer", "Unlimited Members", "$5–25k/mo FDE-embedded", "Outcome upside", "Enterprise"],
-      "mono": "Sierra-shaped: 18 months behind their arc"
-    },
-    {
-      "type": "close",
-      "tagline": "In 2030, every serious AI business runs on a Shadow Center. We are the one underneath.",
-      "buttons": [
-        { "label": "See the demo", "primary": true },
-        { "label": "Talk to us" }
-      ],
-      "footer": "Raising $10M seed · atris.ai · 2026"
-    }
-  ]
-}