atris 3.30.12 → 3.32.0

package/commands/truth.js

@@ -0,0 +1,171 @@
+// atris truth — one table of what is actually proven, blocked, or stale.
+// Rolls up sources that already exist; writes nothing. SQL/state is truth, this is the render.
+//   1. .atris/state/missions.jsonl        — mission states (dedupe by id, latest wins)
+//   2. ~/.atris/tasks.db                  — task counts by status
+//   3. atris/features/*/                  — validate.md frontmatter + newest proof/ receipt age
+//   4. ~/.atris/heartbeat/{registry,state}.json — declared loops vs last_run / fails
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const STALE_DAYS = 7;
+
+function readJson(file) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; }
+}
+
+function daysAgo(ms) {
+  if (!ms) return null;
+  return (Date.now() - ms) / 86400000;
+}
+
+function fmtAge(days) {
+  if (days == null) return 'never';
+  if (days < 1) return `${Math.round(days * 24)}h`;
+  return `${Math.round(days)}d`;
+}
+
+function loadMissions(cwd) {
+  const file = path.join(cwd, '.atris', 'state', 'missions.jsonl');
+  if (!fs.existsSync(file)) return [];
+  const seen = new Map();
+  for (const line of fs.readFileSync(file, 'utf8').split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      const rec = JSON.parse(line);
+      const id = rec.id || rec.mission_id;
+      if (id) seen.set(id, rec);
+    } catch { /* skip bad lines */ }
+  }
+  // stopped = killed-on-purpose = a closed loop; only genuinely open states count
+  return [...seen.values()].filter((m) => m.status && !['complete', 'archived', 'stopped'].includes(m.status));
+}
+
+function loadTaskCounts() {
+  try {
+    const { DatabaseSync } = require('node:sqlite');
+    const db = new DatabaseSync(path.join(os.homedir(), '.atris', 'tasks.db'), { readOnly: true });
+    const rows = db.prepare('SELECT status, COUNT(*) n FROM tasks GROUP BY status').all();
+    db.close();
+    const counts = {};
+    for (const r of rows) counts[r.status] = r.n;
+    return counts;
+  } catch { return null; }
+}
+
+function loadFeatures(cwd) {
+  const dir = path.join(cwd, 'atris', 'features');
+  if (!fs.existsSync(dir)) return [];
+  const out = [];
+  for (const name of fs.readdirSync(dir)) {
+    if (name.startsWith('_')) continue;
+    const fdir = path.join(dir, name);
+    const validate = path.join(fdir, 'validate.md');
+    if (!fs.existsSync(validate)) continue;
+    let status = null;
+    const head = fs.readFileSync(validate, 'utf8').slice(0, 500);
+    const m = head.match(/^status:\s*(.+)$/m);
+    if (m) status = m[1].trim();
+    // newest receipt in proof/ (if any)
+    let proofAgeDays = null;
+    const proofDir = path.join(fdir, 'proof');
+    if (fs.existsSync(proofDir)) {
+      let newest = 0;
+      for (const p of fs.readdirSync(proofDir)) {
+        try { newest = Math.max(newest, fs.statSync(path.join(proofDir, p)).mtimeMs); } catch { /* skip */ }
+      }
+      if (newest) proofAgeDays = daysAgo(newest);
+    }
+    let verdict;
+    if (/blocked/i.test(status || '')) verdict = 'blocked';
+    else if (proofAgeDays != null && proofAgeDays <= STALE_DAYS) verdict = 'proven';
+    else if (proofAgeDays != null) verdict = 'stale';
+    else verdict = 'unproven';
+    out.push({ lane: name, status: status || '-', verdict, proofAgeDays });
+  }
+  return out;
+}
+
+function loadHeartbeats() {
+  const hbDir = path.join(os.homedir(), '.atris', 'heartbeat');
+  const registry = readJson(path.join(hbDir, 'registry.json'));
+  const state = readJson(path.join(hbDir, 'state.json')) || {};
+  if (!registry || !Array.isArray(registry.jobs)) return [];
+  return registry.jobs.filter((j) => !j.disabled).map((j) => {
+    const s = state[j.id] || {};
+    const lastRun = s.last_run ? Date.parse(s.last_run) : null;
+    const ageDays = daysAgo(lastRun);
+    const expectedDays = ((j.cadence_minutes || 60) / 1440) * 3; // 3 missed cadences = stale
+    let verdict;
+    if (s.disabled) verdict = 'disabled';
+    else if ((s.consecutive_fails || 0) > 0) verdict = 'blocked';
+    else if (lastRun == null) verdict = 'never-ran';
+    else if (ageDays > Math.max(expectedDays, 0.05)) verdict = 'stale';
+    else verdict = 'proven';
+    return { id: j.id, verdict, lastRunAgeDays: ageDays, fails: s.consecutive_fails || 0 };
+  });
+}
+
+function truthCommand(args = []) {
+  const cwd = process.cwd();
+  const json = args.includes('--json');
+  const summary = args.includes('--summary');
+
+  const missions = loadMissions(cwd);
+  const tasks = loadTaskCounts();
+  const features = loadFeatures(cwd);
+  const heartbeats = loadHeartbeats();
+
+  const featureTally = {};
+  for (const f of features) featureTally[f.verdict] = (featureTally[f.verdict] || 0) + 1;
+  const loopTally = {};
+  for (const h of heartbeats) loopTally[h.verdict] = (loopTally[h.verdict] || 0) + 1;
+
+  const result = {
+    ok: true,
+    generated_at: new Date().toISOString(),
+    missions_active: missions.map((m) => ({ id: m.id || m.mission_id, status: m.status, owner: m.owner })),
+    tasks,
+    features: featureTally,
+    loops: loopTally,
+    feature_rows: features,
+    loop_rows: heartbeats,
+  };
+
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return 0;
+  }
+
+  const line = (s) => console.log(s);
+  if (summary) {
+    line(`truth: features ${featureTally.proven || 0} proven / ${featureTally.stale || 0} stale / ${featureTally.blocked || 0} blocked / ${featureTally.unproven || 0} unproven · loops ${loopTally.proven || 0} live / ${(loopTally.stale || 0) + (loopTally['never-ran'] || 0)} stale / ${loopTally.blocked || 0} failing · missions ${missions.length} active`);
+    return 0;
+  }
+
+  line('ATRIS TRUTH — live state, not belief\n');
+
+  line(`Missions active: ${missions.length}`);
+  for (const m of missions) line(`  ${m.status.padEnd(8)} ${m.owner || '?'}  ${m.id || m.mission_id}`);
+
+  if (tasks) {
+    line(`\nTasks: ${Object.entries(tasks).map(([k, v]) => `${v} ${k}`).join(', ')}`);
+  }
+
+  line(`\nFeature lanes (${features.length}):`);
+  const order = { blocked: 0, stale: 1, unproven: 2, proven: 3 };
+  for (const f of features.sort((a, b) => (order[a.verdict] ?? 9) - (order[b.verdict] ?? 9))) {
+    line(`  ${f.verdict.padEnd(9)} ${fmtAge(f.proofAgeDays).padStart(6)}  ${f.lane}`);
+  }
+
+  line(`\nLoops (${heartbeats.length}):`);
+  for (const h of heartbeats) {
+    line(`  ${h.verdict.padEnd(9)} ${fmtAge(h.lastRunAgeDays).padStart(6)}  ${h.id}${h.fails ? `  fails=${h.fails}` : ''}`);
+  }
+
+  line(`\nVerdict key: proven = receipt within ${STALE_DAYS}d · stale = receipt older · unproven = no receipt ever · blocked = failing now`);
+  return 0;
+}
+
+module.exports = { truthCommand };

package/commands/xp.js

@@ -18,6 +18,8 @@ const CAREER_XP_CURSOR_FILE = path.join('.atris', 'state', 'career_xp.cursor.jso
 const CAREER_XP_SESSIONS_DIR = path.join('.atris', 'state', 'career_xp_sessions');
 const TASK_PROJECTION_FILE = path.join('.atris', 'state', 'tasks.projection.json');
 const CODEX_STATE_FILE = path.join(os.homedir(), '.codex', 'state_5.sqlite');
+// Codex moved native goals to goals_1.sqlite; thread metadata (cwd/title) stayed in state_5.sqlite.
+const CODEX_GOALS_FILE = path.join(os.homedir(), '.codex', 'goals_1.sqlite');
 const AGENT_XP_LABEL = 'AgentXP';
 const AGENTXP_LEADERBOARD_URL = 'https://api.atris.ai/api/agentxp/leaderboard';
 const LEVEL_XP = 1000;
@@ -1549,20 +1551,42 @@ function workspacePathCandidates(workspace) {
   return [...new Set(candidates.filter(Boolean))];
 }
 
+function codexHasThreadsTable(dbPath) {
+  if (!dbPath || !fs.existsSync(dbPath)) return false;
+  return runSqliteJsonOptional(dbPath, `SELECT name FROM sqlite_master WHERE type='table' AND name='threads' LIMIT 1;`).length > 0;
+}
+
 function readCodexGoalsForSession(args, workspace, sinceMs, untilMs) {
-  const dbPath = path.resolve(expandHome(
-    readFlag(args, '--codex-state', readFlag(args, '--state', process.env.CODEX_STATE_DB || CODEX_STATE_FILE))
-  ));
+  const explicitDb = readFlag(args, '--codex-state', readFlag(args, '--state', process.env.CODEX_STATE_DB || ''));
+  const dbPath = explicitDb
+    ? path.resolve(expandHome(explicitDb))
+    : path.resolve(fs.existsSync(CODEX_GOALS_FILE) ? CODEX_GOALS_FILE : CODEX_STATE_FILE);
+
+  // Goals live in goals_1.sqlite (no `threads` table); cwd/title metadata lives in state_5.sqlite.
+  // Legacy single-file layouts (and test fixtures) keep both in one DB.
+  let threadsTable = codexHasThreadsTable(dbPath) ? 'threads' : null;
+  let attachPrefix = '';
+  if (!threadsTable) {
+    const threadsDb = CODEX_STATE_FILE !== dbPath ? CODEX_STATE_FILE : '';
+    if (codexHasThreadsTable(threadsDb)) {
+      threadsTable = 'tdb.threads';
+      attachPrefix = `ATTACH ${sqlString(threadsDb)} AS tdb;\n`;
+    }
+  }
+
   const threadId = readFlag(args, '--thread', process.env.CODEX_THREAD_ID || '');
   const clauses = [];
   if (threadId) clauses.push(`tg.thread_id = ${sqlString(threadId)}`);
   const workspaceCandidates = workspacePathCandidates(workspace);
-  if (workspaceCandidates.length) {
+  if (workspaceCandidates.length && threadsTable) {
     clauses.push(`(t.cwd IN (${workspaceCandidates.map(sqlString).join(', ')}) AND tg.created_at_ms <= ${Number(untilMs)} AND (tg.updated_at_ms >= ${Number(sinceMs)} OR tg.status = 'active'))`);
   }
   if (!clauses.length) return [];
 
-  const rows = runSqliteJsonOptional(dbPath, `
+  const join = threadsTable ? `LEFT JOIN ${threadsTable} t ON t.id = tg.thread_id` : '';
+  const cwdCol = threadsTable ? 't.cwd' : 'NULL';
+  const titleCol = threadsTable ? 't.title' : 'NULL';
+  const rows = runSqliteJsonOptional(dbPath, `${attachPrefix}
 SELECT
   'codex' AS provider,
   tg.thread_id,
@@ -1574,10 +1598,10 @@ SELECT
   tg.time_used_seconds,
   tg.created_at_ms,
   tg.updated_at_ms,
-  t.cwd AS thread_cwd,
-  t.title AS thread_title
+  ${cwdCol} AS thread_cwd,
+  ${titleCol} AS thread_title
 FROM thread_goals tg
-LEFT JOIN threads t ON t.id = tg.thread_id
+${join}
 WHERE ${clauses.join(' OR ')}
 ORDER BY tg.updated_at_ms DESC
 LIMIT 25

package/commands/youtube.js

@@ -3,7 +3,11 @@ 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_QUERY = [
+  'Create a timestamped YouTube brief for Atris.',
+  'Include: metadata, timestamped outline, core claims with confidence, memorable examples, actionable takeaways, Atris/product implications, and next actions.',
+  'Use transcript timestamps whenever possible.',
+].join(' ');
 const DEFAULT_TIMEOUT_MS = 300000;
 const LOCAL_TRANSCRIPT_MAX_BYTES = 5 * 1024 * 1024;
 const LOCAL_TRANSCRIPT_MAX_CHARS = 250000;
@@ -18,7 +22,8 @@ function showYoutubeHelp(output = console.log, commandName = 'atris youtube') {
   output(`Usage: ${commandName} process <youtube-url> [options]`);
   output(`       ${commandName} <youtube-url> [options]`);
   output('');
-  output('Process a YouTube video through Atris using transcript-first analysis.');
+  output('Process a YouTube video through Atris using timestamped transcript-first analysis.');
+  output('Falls back to cloud video processing when local captions are unavailable.');
   output('');
   output('Options:');
   output('  --query, -q <text>  Focus question for the analysis');
@@ -28,6 +33,9 @@ function showYoutubeHelp(output = console.log, commandName = 'atris youtube') {
   output('  --json              Print the raw JSON response');
   output('  -h, --help          This help');
   output('');
+  output('Default output contract:');
+  output('  metadata -> timestamped outline -> claims -> examples -> takeaways -> Atris implications -> next actions');
+  output('');
   output('Examples:');
   output(`  ${commandName} https://www.youtube.com/watch?v=VIDEO_ID`);
   output(`  ${commandName} process https://youtu.be/VIDEO_ID --query "Key takeaways"`);
@@ -186,6 +194,34 @@ function chooseCaptionTrack(info = {}) {
   return chooseFrom(info.subtitles) || chooseFrom(info.automatic_captions);
 }
 
+function formatTimestampFromMs(ms) {
+  const totalSeconds = Math.max(0, Math.floor(Number(ms || 0) / 1000));
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = totalSeconds % 60;
+  const two = (value) => String(value).padStart(2, '0');
+  return hours > 0
+    ? `${two(hours)}:${two(minutes)}:${two(seconds)}`
+    : `${two(minutes)}:${two(seconds)}`;
+}
+
+function timestampedCaptionLine(text, startMs) {
+  const clean = String(text || '').replace(/\s+/g, ' ').trim();
+  if (!clean) return '';
+  if (!Number.isFinite(Number(startMs))) return clean;
+  return `[${formatTimestampFromMs(startMs)}] ${clean}`;
+}
+
+function parseVttTimestampMs(value) {
+  const match = String(value || '').match(/(?:(\d{2}):)?(\d{2}):(\d{2})\.(\d{3})/);
+  if (!match) return null;
+  const hours = Number(match[1] || 0);
+  const minutes = Number(match[2] || 0);
+  const seconds = Number(match[3] || 0);
+  const millis = Number(match[4] || 0);
+  return ((hours * 3600) + (minutes * 60) + seconds) * 1000 + millis;
+}
+
 function fetchCaptionText(urlString, redirects = 0) {
   if (!captionHostAllowed(urlString)) {
     return Promise.resolve(null);
@@ -246,15 +282,37 @@ function parseCaptionText(raw) {
           .replace(/\s+/g, ' ')
           .trim();
         if (!text) continue;
-        if (segments[segments.length - 1] === text) continue;
-        segments.push(text);
+        const line = timestampedCaptionLine(text, Number(event.tStartMs));
+        if (segments[segments.length - 1] === line) continue;
+        segments.push(line);
       }
-      return segments.join(' ');
+      return segments.join('\n');
     } catch {
       return '';
     }
   }
 
+  if (/^WEBVTT/i.test(trimmed) || trimmed.includes('-->')) {
+    const segments = [];
+    for (const block of String(raw).split(/\r?\n\r?\n+/)) {
+      const lines = block.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+      const timeLine = lines.find((line) => line.includes('-->'));
+      if (!timeLine) continue;
+      const startMs = parseVttTimestampMs(timeLine.split('-->')[0]);
+      const text = lines.slice(lines.indexOf(timeLine) + 1)
+        .filter((line) => !/^(NOTE|STYLE|REGION|Kind:|Language:)/.test(line))
+        .map((line) => line.replace(/<[^>]+>/g, '').replace(/\s+/g, ' ').trim())
+        .filter(Boolean)
+        .filter((line, index, all) => index === 0 || line !== all[index - 1])
+        .join(' ')
+        .trim();
+      const captionLine = timestampedCaptionLine(text, startMs);
+      if (!captionLine || segments[segments.length - 1] === captionLine) continue;
+      segments.push(captionLine);
+    }
+    if (segments.length) return segments.join('\n');
+  }
+
   const segments = [];
   for (const line of String(raw).split(/\r?\n/)) {
     const stripped = line.trim();
@@ -358,6 +416,14 @@ function formatYoutubeResult(data) {
   lines.push(data?.message || 'YouTube video processed successfully');
   if (metadata.title) lines.push(`Title: ${metadata.title}`);
   if (metadata.channel) lines.push(`Channel: ${metadata.channel}`);
+  if (metadata.duration_seconds) lines.push(`Duration: ${formatTimestampFromMs(Number(metadata.duration_seconds) * 1000)}`);
+  if (metadata.processing_method || metadata.transcript_source) {
+    const method = metadata.processing_method || metadata.transcript_source;
+    const source = metadata.transcript_source && metadata.transcript_source !== method
+      ? ` via ${metadata.transcript_source}`
+      : '';
+    lines.push(`Processing: ${method}${source}`);
+  }
   if (data?.credits_used !== undefined || data?.credits_remaining !== undefined) {
     const used = data.credits_used !== undefined ? data.credits_used : '?';
     const remaining = data.credits_remaining !== undefined ? data.credits_remaining : '?';
@@ -393,5 +459,6 @@ module.exports = {
   processYoutube,
   shouldRetryWithLocalTranscript,
   formatYoutubeResult,
+  formatTimestampFromMs,
   youtubeCommand,
 };

package/decks/README.md

@@ -23,28 +23,28 @@ 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
+atris deck lint decks/atris-one-loop-pitch.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
+atris deck build decks/atris-one-loop-pitch.json --title "Atris One Loop" --review
 
 # Rebuild an existing deck in place (URL/id stay stable)
-atris deck build decks/atris-seed-pitch-v3.json --update 139zTe9cPOGttzYbW04adRU26VJz0SqWRwaZmkoVibP8
+atris deck build decks/atris-one-loop-pitch.json --update 139zTe9cPOGttzYbW04adRU26VJz0SqWRwaZmkoVibP8
 
 # Batch-build several specs
-atris deck build decks/atris-seed-pitch-v3.json decks/mark-pincus-narrative.json
+atris deck build decks/atris-one-loop-pitch.json decks/atris-antislop-pitch.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
+atris deck review 139zTe9cPOGttzYbW04adRU26VJz0SqWRwaZmkoVibP8 --spec decks/atris-one-loop-pitch.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
+atris deck history decks/atris-one-loop-pitch.json
 ```
 
 ## Themes
@@ -76,13 +76,7 @@ List all: `atris deck themes`
 
 | 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 |

package/lib/auto-accept-certified.js

@@ -92,6 +92,15 @@ function isAllowedGitDiffCheck(argv) {
   return false;
 }
 
+function isAllowedAtrisCleanDryRun(argv) {
+  return argv.length === 5
+    && argv[0] === 'node'
+    && argv[1] === 'bin/atris.js'
+    && argv[2] === 'clean'
+    && argv[3] === '--dry-run'
+    && argv[4] === '--json';
+}
+
 function isInsidePath(candidate, root) {
   const relative = path.relative(root, candidate);
   return relative === '' || (relative && !relative.startsWith('..') && !path.isAbsolute(relative));
@@ -209,6 +218,7 @@ function parseVerifyCommand(verify) {
       || (/^scripts\/[a-zA-Z0-9_./-]+$/.test(first || '') && safeNodePathArgs(argv.slice(1)))
     ))
     || (bin === 'tsc' && argv.length === 1)
+    || isAllowedAtrisCleanDryRun(argv)
     || isAllowedGitDiffCheck(argv);
   if (!allowed) return { ok: false, reason: 'verify_command_not_allowed' };
   return { ok: true, argv };