atris 3.46.1 → 3.48.0

package/atris/skills/design/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: design
 description: Frontend aesthetics policy. Use when building UI, components, landing pages, dashboards, or any frontend work. Prevents generic ai-generated look.
-version: 3.1.0
+version: 3.1.1
 allowed-tools: Read, Write, Edit, Bash, Glob
 tags:
   - design
@@ -112,6 +112,7 @@ Every entry: id, rule, detector, status. A detector is a regex/command a gate ca
 | D11 | layout contracts, not dioramas: min-height over fixed height, fluid max-width over fixed px, every overflow reachable (scroll or +N more), stress-test with hostile content before shipping | judgment | active |
 | D12 | one accent moment per card: brand accent for the primary action only, gold for confidence/progress fills, green only for completed; everything else tonal | judgment | active |
 | D13 | motion is calm and eased: 120-300ms ease-out on opacity/transform only, loops match a measured source cadence, prefers-reduced-motion always freezes them | judgment | active |
+| D14 | compact selectors lead with the chosen name and a discriminating icon; remove redundant field labels and visible type explanations when icon, title, and accessible label carry them | judgment | active |
 
 Measured recipes live in the mimic studies: `~/arena/mimic-beautiful-ui/LESSONS.md` (18 AI-interface components with exact tokens) and its `remix.css` :root block (the portable Atris token sheet, coffee + paper themes). Start there before designing an agent surface.
 

package/atris/skills/youtube/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: youtube
-description: "Process YouTube videos — extract insights, answer questions, store as knowledge. 5 credits per video. Triggers on: youtube, video, process video, watch this, learn from video."
+description: "Process YouTube videos: extract insights, answer questions, store as knowledge. 5 credits per video. Triggers on: youtube, video, process video, watch this, learn from video."
 version: 2.3.0
 tags:
   - youtube
@@ -15,9 +15,11 @@ Process any YouTube video through Atris transcript-first analysis. The CLI extra
 
 ## Route first: learning vs product
 
-Two rails process YouTube videos — pick before running anything:
+Two rails process YouTube videos: pick before running anything:
 
 - **Learning / work rail** → use the `alpha-learn` skill (ytnotes). Local yt-dlp + grok, zero credits, podcastnotes-style notes, tweet-feed output, `[claimable]` entries in today's journal for other agents. Use this when the goal is to LEARN from a video or mine it for Atris work.
+  Canonical ytnotes source is `scripts/det/ytnotes` (install: `ln -sf "$PWD/scripts/det/ytnotes" ~/.local/bin/ytnotes`).
+  Runs are scored by `node scripts/det/ytrail-eval.js`.
 - **Product rail** → this skill (`atris youtube process`). Credits-billed, stores knowledge in the Atris backend, customer-facing path. Use this when a customer/agent needs the video stored as Atris knowledge or answered via the API.
 
 If the user says "learn from", "notes on", "alpha", or "rabbit hole" → alpha-learn. If they say "process", "store", "add to knowledge" → this skill.
@@ -189,7 +191,7 @@ Every important insight should carry a timestamp when the transcript provides on
 | `401` | Token expired/invalid | `atris login --force` |
 | `402` | Not enough credits | Check balance, purchase at atris.ai |
 | `400` | Invalid YouTube URL | Check URL format |
-| `502` | Transcript or cloud processing failed | Retry — credits auto-refunded when backend fails |
+| `502` | Transcript or cloud processing failed | Retry; credits auto-refunded when backend fails |
 
 ---
 

package/bin/atris.js

@@ -38,6 +38,7 @@ try {
 const {
   checkForUpdates,
   showUpdateNotification,
+  autoUpdate,
   inspectInstallGitState,
   formatInstallGitWarning,
 } = require('../utils/update-check');
@@ -106,6 +107,7 @@ if (!skipUpdateCheck && (!updateCommand || (updateCommand && !['version', 'updat
         showUpdateNotification(updateInfo, {
           packageRoot: path.join(__dirname, '..'),
         });
+        autoUpdate(updateInfo, { packageRoot: path.join(__dirname, '..') });
       }
       return updateInfo;
     })
@@ -569,7 +571,7 @@ function showHelp() {
   console.log('  router     - inspect ax lane outcomes and promote gated reflex overrides');
   console.log('  sign       - Co-author trailer on every commit in an atris workspace (on/off/status)');
   console.log('  visualize  - Generate a Slack/deck-ready visual from a prompt');
-  console.log('  youtube    - Process YouTube videos with timestamped transcript-first analysis');
+  console.log('  youtube    - Free local notes or 5-credit cloud process for YouTube videos');
   console.log('');
   console.log('Experiments:');
   console.log('  experiments init [slug]     - Prepare atris/experiments/ or scaffold a pack');

package/commands/ci.js

@@ -14,7 +14,7 @@ function showCiHelp() {
   console.log('atris ci runs github actions jobs on this machine with a warm local work folder.');
   console.log('change runs-on: ubuntu-latest to runs-on: atris.');
   console.log('a GITHUB_TOKEN or an authenticated gh cli is required.');
-  console.log('usage: atris ci runner --repo <owner/name> [--label <name>] [--once]');
+  console.log('usage: atris ci runner --repo <owner/name> [--repo <owner/name> ...] [--label <name>] [--once]');
   console.log('       atris ci usage [--repo <owner/name>]');
 }
 

package/commands/close.js

@@ -1,6 +1,7 @@
 const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
+const { spawnSync } = require('child_process');
 const { knownCommands } = require('../lib/known-commands');
 const { readUsage, usagePath } = require('../lib/usage');
 const pulse = require('../lib/pulse');
@@ -16,6 +17,12 @@ const EXPERIMENTS_RELATIVE_PATH = path.join('.atris', 'state', 'experiments.json
 const EXPERIMENTS_DIR_RELATIVE_PATH = path.join('atris', 'experiments');
 const RESOLVED_IN_SOURCE_PROOF = 'resolved in source store';
 const FAILED_TASK_BATCH_PREFIX = 'tasks:failed:';
+// Live-probe incidents: a diagnosis may only be recorded alongside a command
+// that fails right now, and may only close after that command passes twice
+// with a real gap between runs (catches the bug that comes back hours later).
+const PROBE_TIMEOUT_MS = 60 * 1000;
+const PROBE_HOLD_GAP_MS = 60 * 60 * 1000;
+const PROBE_STOP_AFTER_FAILED_CHECKS = 2;
 
 function ledgerPath(cwd = process.cwd()) {
   return path.join(cwd, LEDGER_RELATIVE_PATH);
@@ -111,6 +118,8 @@ function foldEvents(events, options = {}) {
         ttl_days: Number(event.ttl_days) || 7,
         close_condition: normalizeSpaces(event.close_condition || 'the loop is resolved'),
         source: normalizeSpaces(event.source || 'manual'),
+        probe: normalizeSpaces(event.probe || '') || null,
+        probe_runs: [],
         status: 'open',
         closed_at: null,
         dissolved_at: null,
@@ -138,6 +147,12 @@ function foldEvents(events, options = {}) {
     } else if (event.kind === 'escalated') {
       const day = event.day || (event.at ? String(event.at).slice(0, 10) : null);
       if (day && !flag.escalated_days.includes(day)) flag.escalated_days.push(day);
+    } else if (event.kind === 'probed') {
+      flag.probe_runs.push({
+        at: eventTime(event),
+        pass: !!event.pass,
+        exit_code: Number.isFinite(event.exit_code) ? event.exit_code : null,
+      });
     }
   }
 
@@ -161,9 +176,49 @@ function withComputedState(flag, now = new Date()) {
     days_old: daysOld,
     days_past_ttl: daysPastTtl,
     overdue,
+    ...probeState(flag),
   };
 }
 
+// Probe state from recorded runs. 'failing' until a check passes, 'passed
+// once' until a second pass lands PROBE_HOLD_GAP_MS later, then 'holding'
+// (eligible to close). failed_checks counts re-checks that still failed:
+// each one is a fix attempt that did not move reality.
+function probeState(flag) {
+  if (!flag.probe) {
+    return { probe_status: null, failed_checks: 0, probe_holding: false };
+  }
+  const runs = flag.probe_runs || [];
+  const failedChecks = runs.filter((run) => !run.pass).length;
+
+  const trailing = [];
+  for (let index = runs.length - 1; index >= 0 && runs[index].pass; index -= 1) {
+    trailing.unshift(runs[index]);
+  }
+
+  let status = 'failing';
+  let holding = false;
+  if (trailing.length >= 1) {
+    const firstMs = parseDate(trailing[0].at) || 0;
+    const lastMs = parseDate(trailing[trailing.length - 1].at) || 0;
+    holding = trailing.length >= 2 && lastMs - firstMs >= PROBE_HOLD_GAP_MS;
+    status = holding ? 'holding' : 'passed once';
+  }
+  return { probe_status: status, failed_checks: failedChecks, probe_holding: holding };
+}
+
+function runProbe(command, context = {}) {
+  const result = spawnSync(command, {
+    shell: true,
+    cwd: context.cwd || process.cwd(),
+    timeout: PROBE_TIMEOUT_MS,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    encoding: 'utf8',
+  });
+  const exitCode = typeof result.status === 'number' ? result.status : 1;
+  return { pass: exitCode === 0, exit_code: exitCode };
+}
+
 function openFlags(cwd = process.cwd(), options = {}) {
   return foldEvents(readEvents(cwd), options).filter((flag) => flag.status === 'open');
 }
@@ -202,6 +257,7 @@ function listLine(flag) {
     flag.what.toLowerCase(),
     `${formatDays(flag.days_old)} old`,
   ];
+  if (flag.probe) parts.push(`probe ${flag.probe_status}`);
   if (flag.overdue) {
     parts.push(`${formatDays(flag.days_past_ttl)} past ttl`);
   }
@@ -269,10 +325,11 @@ function publicFlag(flag) {
 }
 
 function printHelp() {
-  console.log('usage: atris close <add|list|done|dissolve|snooze|sweep|scan>');
-  console.log('add "<what>" [--owner x] [--lane life|business|code] [--ttl 7] [--when "<condition>"] [--source y]');
+  console.log('usage: atris close <add|list|done|dissolve|snooze|sweep|scan|check>');
+  console.log('add "<what>" [--owner x] [--lane life|business|code] [--ttl 7] [--when "<condition>"] [--source y] [--probe "<cmd that fails now>"]');
   console.log('list [--json] [--lane x]');
-  console.log('done <id> [--proof "..."]');
+  console.log('done <id> [--proof "..."]  (a probed incident closes only after its probe holds)');
+  console.log('check [id] [--json]  (run live probes; failing probe = old theory still live)');
   console.log('dissolve <id> --why "..."');
   console.log('snooze <id> --days n');
   console.log('sweep [--json]');
@@ -295,6 +352,20 @@ function commandAdd(args, context = {}) {
     return 0;
   }
 
+  // A probe turns the flag into a live incident: the claim in `what` is only
+  // recordable while the probe command fails. A passing probe means there is
+  // nothing to diagnose, so refuse instead of storing a story.
+  if (options.probe === true) throw new Error('--probe needs a command');
+  const probe = normalizeSpaces(options.probe || '');
+  let probeExit = null;
+  if (probe) {
+    const result = (context.runProbe || runProbe)(probe, context);
+    if (result.pass) {
+      throw new Error('probe passes right now; an incident needs a command that currently fails. fix the probe or drop --probe');
+    }
+    probeExit = result.exit_code;
+  }
+
   const openedAt = now.toISOString();
   const event = {
     kind: 'opened',
@@ -308,11 +379,88 @@ function commandAdd(args, context = {}) {
     close_condition: normalizeSpaces(options.when || 'the loop is resolved'),
     source: normalizeSpaces(options.source || 'manual'),
   };
+  if (probe) event.probe = probe;
   appendEvent(event, context.cwd);
-  console.log(`opened ${event.id}`);
+  if (probe) {
+    console.log(`opened ${event.id}, probe failing as required (exit ${probeExit})`);
+  } else {
+    console.log(`opened ${event.id}`);
+  }
   return 0;
 }
 
+// atris close check [id] — run the live probes on open incidents. This is the
+// first move for any session entering an area: if a probe still fails, the
+// recorded theory is still live; do not diagnose fresh. After
+// PROBE_STOP_AFTER_FAILED_CHECKS failing re-checks the verdict is automatic:
+// stop and tell the human.
+function commandCheck(args, context = {}) {
+  const { positional, options } = parseArgs(args);
+  const id = positional[0] || null;
+  const now = context.now ? new Date(context.now) : new Date();
+
+  let flags = openFlags(context.cwd, { now }).filter((flag) => flag.probe);
+  if (id) {
+    flags = flags.filter((flag) => flag.id === id);
+    if (flags.length === 0) throw new Error(`${id} is not an open incident with a probe`);
+  }
+  if (flags.length === 0) {
+    console.log('no open incidents with probes.');
+    return 0;
+  }
+
+  const results = [];
+  for (const flag of flags) {
+    const run = (context.runProbe || runProbe)(flag.probe, context);
+    appendEvent({
+      kind: 'probed',
+      at: now.toISOString(),
+      id: flag.id,
+      pass: run.pass,
+      exit_code: run.exit_code,
+    }, context.cwd);
+    results.push({ id: flag.id, what: flag.what, ...run });
+  }
+
+  const after = new Map(
+    openFlags(context.cwd, { now }).map((flag) => [flag.id, flag])
+  );
+
+  if (options.json) {
+    printJson({
+      checked: results.map((result) => {
+        const flag = after.get(result.id);
+        return {
+          ...result,
+          probe_status: flag ? flag.probe_status : null,
+          failed_checks: flag ? flag.failed_checks : null,
+        };
+      }),
+    });
+    return 0;
+  }
+
+  let anyFailing = false;
+  for (const result of results) {
+    const flag = after.get(result.id);
+    if (result.pass) {
+      if (flag && flag.probe_holding) {
+        console.log(`${result.id}: probe held. close it: atris close done ${result.id}`);
+      } else {
+        console.log(`${result.id}: probe passed once. re-check in an hour to confirm it holds.`);
+      }
+      continue;
+    }
+    anyFailing = true;
+    const failedChecks = flag ? flag.failed_checks : 0;
+    console.log(`${result.id}: probe still failing (exit ${result.exit_code}). the recorded theory is still live.`);
+    if (failedChecks >= PROBE_STOP_AFTER_FAILED_CHECKS) {
+      console.log(`${result.id}: ${failedChecks} fix attempts have not moved the probe. stop and tell the human.`);
+    }
+  }
+  return anyFailing ? 1 : 0;
+}
+
 function commandList(args, context = {}) {
   const { options } = parseArgs(args);
   const lane = options.lane ? String(options.lane).toLowerCase() : null;
@@ -346,13 +494,25 @@ function commandDone(args, context = {}) {
   const { positional, options } = parseArgs(args);
   const id = positional[0];
   if (!id) throw new Error('id is required');
-  requireOpenFlag(id, context);
+  const flag = requireOpenFlag(id, context);
+
+  // An incident with a live probe closes on held evidence, not on a claim:
+  // the probe must pass twice, an hour apart, so the storm that returns
+  // hours later cannot be marked solved in the same breath as the fix.
+  if (flag.probe && !flag.probe_holding) {
+    if (flag.probe_status === 'failing') {
+      throw new Error(`probe still fails; run the fix, then: atris close check ${id}`);
+    }
+    throw new Error(`probe passed once; confirm it holds with atris close check ${id} at least an hour after the first pass`);
+  }
+
   const at = (context.now ? new Date(context.now) : new Date()).toISOString();
+  const defaultProof = flag.probe ? `probe held: ${flag.probe}` : '';
   appendEvent({
     kind: 'closed',
     at,
     id,
-    proof: normalizeSpaces(options.proof || ''),
+    proof: normalizeSpaces(options.proof || defaultProof),
   }, context.cwd);
   console.log(`closed ${id}`);
   return 0;
@@ -1097,6 +1257,7 @@ function run(args = [], context = {}) {
     if (subcommand === 'snooze') return commandSnooze(rest, context);
     if (subcommand === 'sweep') return commandSweep(rest, context);
     if (subcommand === 'scan') return commandScan(rest, context);
+    if (subcommand === 'check') return commandCheck(rest, context);
     console.error(`unknown close command: ${subcommand}`);
     return 2;
   } catch (error) {

package/commands/mission.js

@@ -23,6 +23,7 @@ const {
 } = require('../lib/runner-command');
 const {
   resolveEngineForRoleWithPreference,
+  engineFailureHealthStatus,
   setEngineHealth,
 } = require('../lib/engine-registry');
 const {
@@ -378,28 +379,6 @@ function resolveMissionTickRunner(mission, root = process.cwd()) {
   };
 }
 
-function engineFailureHealthStatus(result) {
-  if (!result || result.status !== 'errored') return null;
-  const signalText = [
-    result.reason,
-    result.model_unavailable,
-    result.claude && result.claude.summary,
-    result.claude && result.claude.receipt_text,
-    result.claude && result.claude.stderr,
-    result.rate_limit_info && JSON.stringify(result.rate_limit_info),
-  ].filter(Boolean).join('\n').toLowerCase();
-  if (/usage[ _-]?limit|purchase more credits|insufficient credits|credit(?:s)?[ _-]?(?:out|limit)|rate[ _-]?limit/.test(signalText)) {
-    return 'credit_out';
-  }
-  if (/timeout|model-unavailable/.test(signalText)) return 'not_installed';
-  // Any other errored tick (claude-error, no-ready-engine's sibling failures,
-  // etc.) is still a real failure signal for the engine that ran it. Falling
-  // through to null here left the registry showing "ready" for an engine
-  // that had just hard-failed (e.g. a 401), so auto routing kept sending
-  // ticks back to it. Mark it "error" instead of silently doing nothing.
-  return 'error';
-}
-
 function recordMissionEngineTickOutcome(engineId, result, root = process.cwd()) {
   if (!engineId) return null;
   const status = result && result.status === 'ran' ? 'ready' : engineFailureHealthStatus(result);

package/commands/youtube.js

@@ -1,8 +1,12 @@
 const { apiRequestJson } = require('../utils/api');
 const { ensureValidCredentials } = require('../utils/auth');
 const { spawnSync } = require('child_process');
+const path = require('path');
 const https = require('https');
 
+const YTNOTES_USAGE = 'usage: ytnotes <youtube-url> [haiku|atris-fast|gemini|grok|codex|cursor]';
+const YTNOTES_HINT = 'zero credits, local captions + a fast engine';
+
 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.',
@@ -19,9 +23,11 @@ const ALLOWED_CAPTION_HOST_SUFFIXES = [
 
 function showYoutubeHelp(output = console.log, commandName = 'atris youtube') {
   output('');
-  output(`Usage: ${commandName} process <youtube-url> [options]`);
+  output(`Usage: ${commandName} notes <youtube-url> [engine]`);
+  output(`       ${commandName} process <youtube-url> [options]`);
   output(`       ${commandName} <youtube-url> [options]`);
   output('');
+  output('notes = free local notes, process = 5 credits cloud knowledge');
   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('');
@@ -37,6 +43,7 @@ function showYoutubeHelp(output = console.log, commandName = 'atris youtube') {
   output('  metadata -> timestamped outline -> claims -> examples -> takeaways -> Atris implications -> next actions');
   output('');
   output('Examples:');
+  output(`  ${commandName} notes https://www.youtube.com/watch?v=VIDEO_ID`);
   output(`  ${commandName} https://www.youtube.com/watch?v=VIDEO_ID`);
   output(`  ${commandName} process https://youtu.be/VIDEO_ID --query "Key takeaways"`);
   output('');
@@ -437,8 +444,31 @@ function formatYoutubeResult(data) {
   return lines.join('\n');
 }
 
+function runYoutubeNotes(args = [], deps = {}) {
+  const output = deps.output || ((line = '') => console.error(line));
+  const url = args[0];
+  const engine = args[1];
+  if (!url) {
+    output(YTNOTES_USAGE);
+    output(YTNOTES_HINT);
+    return 2;
+  }
+
+  const script = path.join(__dirname, '..', 'scripts', 'det', 'ytnotes');
+  const spawn = deps.spawnSync || spawnSync;
+  const childArgs = engine ? [url, engine] : [url];
+  const result = spawn(script, childArgs, { stdio: 'inherit' });
+  if (result.status == null) return 1;
+  return result.status;
+}
+
 async function youtubeCommand(argv = process.argv.slice(3), deps = {}) {
   const output = deps.output || ((line = '') => console.log(line));
+  if (argv[0] === 'notes') {
+    const code = runYoutubeNotes(argv.slice(1), deps);
+    if (!deps.output && !deps.spawnSync) process.exit(code);
+    return code;
+  }
   const options = parseYoutubeArgs(argv);
   if (options.help) {
     showYoutubeHelp(output, deps.commandName || 'atris youtube');