atris 3.48.0 → 3.49.0

package/commands/youtube.js

@@ -1,6 +1,7 @@
 const { apiRequestJson } = require('../utils/api');
 const { ensureValidCredentials } = require('../utils/auth');
 const { spawnSync } = require('child_process');
+const fs = require('fs');
 const path = require('path');
 const https = require('https');
 
@@ -444,6 +445,67 @@ function formatYoutubeResult(data) {
   return lines.join('\n');
 }
 
+function videoIdFromUrl(url) {
+  const text = String(url || '');
+  const watch = text.match(/[?&]v=([^&]+)/);
+  if (watch) return watch[1];
+  const short = text.match(/youtu\.be\/([^?&/]+)/);
+  return short ? short[1] : null;
+}
+
+function dateStamp(now) {
+  if (typeof now === 'string' && /^\d{4}-\d{2}-\d{2}/.test(now)) {
+    return now.slice(0, 10);
+  }
+  const value = now instanceof Date ? now : new Date(now || Date.now());
+  if (Number.isNaN(value.getTime())) return new Date().toISOString().slice(0, 10);
+  return value.toISOString().slice(0, 10);
+}
+
+function firstHeading(notes) {
+  const match = String(notes || '').replace(/\r\n/g, '\n').match(/^#{1,6}\s+(.+)$/m);
+  return match ? match[1].trim() : '';
+}
+
+function fileBriefFromNotes({ cwd, url, workDir, now } = {}) {
+  try {
+    const id = videoIdFromUrl(url);
+    if (!id) return;
+    const notesPath = path.join(workDir, `yt_${id}.md`);
+    if (!fs.existsSync(notesPath)) return;
+    const notes = fs.readFileSync(notesPath, 'utf8');
+    const wikiDir = path.join(cwd, 'atris', 'wiki');
+    if (!fs.existsSync(wikiDir)) return;
+
+    const heading = firstHeading(notes);
+    const date = dateStamp(now);
+    const header = [
+      heading.toLowerCase(),
+      '',
+      `date: ${date}`,
+      `source: ${url}`,
+      'rail: atris youtube notes, quotes repaired against the transcript',
+    ].join('\n');
+    const briefsDir = path.join(wikiDir, 'briefs');
+    fs.mkdirSync(briefsDir, { recursive: true });
+    const relBrief = `atris/wiki/briefs/youtube-${id}.md`;
+    fs.writeFileSync(path.join(cwd, relBrief), `${header}\n${notes}`);
+
+    const year = date.slice(0, 4);
+    const journalPath = path.join(cwd, 'atris', 'logs', year, `${date}.md`);
+    fs.mkdirSync(path.dirname(journalPath), { recursive: true });
+    let existing = '';
+    if (fs.existsSync(journalPath)) existing = fs.readFileSync(journalPath, 'utf8');
+    const prefix = existing && !existing.endsWith('\n') ? '\n' : '';
+    const line = `- [claimable] watched: ${heading} -> ${relBrief}`;
+    fs.writeFileSync(journalPath, `${existing}${prefix}${line}\n`);
+
+    console.log(`brief filed: ${relBrief}`);
+  } catch {
+    // notes filing must never break the youtube command
+  }
+}
+
 function runYoutubeNotes(args = [], deps = {}) {
   const output = deps.output || ((line = '') => console.error(line));
   const url = args[0];
@@ -459,6 +521,14 @@ function runYoutubeNotes(args = [], deps = {}) {
   const childArgs = engine ? [url, engine] : [url];
   const result = spawn(script, childArgs, { stdio: 'inherit' });
   if (result.status == null) return 1;
+  if (result.status === 0) {
+    fileBriefFromNotes({
+      cwd: deps.cwd || process.cwd(),
+      url,
+      workDir: deps.workDir || path.join(process.env.TMPDIR || '/tmp', 'ytnotes'),
+      now: deps.now || new Date(),
+    });
+  }
   return result.status;
 }
 
@@ -488,5 +558,6 @@ module.exports = {
   processYoutube,
   shouldRetryWithLocalTranscript,
   formatYoutubeResult,
+  fileBriefFromNotes,
   youtubeCommand,
 };

package/lib/engine-registry.js

@@ -33,6 +33,7 @@ function engineFailureHealthStatus(result) {
   if (/usage[ _-]?limit|purchase more credits|insufficient credits|credit(?:s)?[ _-]?(?:out|limit)|rate[ _-]?limit|not authenticated|please log in|login required|auth(?:entication)?[ _-]?expired|payment required|subscription/.test(signalText)) {
     return 'credit_out';
   }
+  if (/not installed|command not found|\benoent\b/.test(signalText)) return 'not_installed';
   if (/timeout|model-unavailable/.test(signalText)) return 'not_installed';
   return 'error';
 }

package/lib/fleet.js

@@ -208,7 +208,7 @@ function buildEngineCommand(engineName, promptFile, { yolo = false, sealed = fal
     if (sealed && engineName === 'codex') {
       cmd = cmd.replace(/\bexec\b/, 'exec --sandbox workspace-write --ephemeral --ignore-user-config --ignore-rules');
     }
-    if (sealed && engineName === 'claude') {
+    if (sealed && (engineName === 'claude' || engineName === 'fable')) {
       cmd = `${cmd} --safe-mode --no-session-persistence --permission-mode acceptEdits --settings '${JSON.stringify({ sandbox: { enabled: true, autoAllowBashIfSandboxed: true } })}'`;
     }
     if (sealed && engineName === 'cursor') cmd = `${cmd} --sandbox enabled`;
@@ -218,7 +218,7 @@ function buildEngineCommand(engineName, promptFile, { yolo = false, sealed = fal
     }
     if (engineName === 'devin') return cmd.replace(/^devin -p /, 'devin -p --permission-mode dangerous ');
     if (yolo && engineName === 'codex') cmd = cmd.replace(/\bexec\b/, `exec ${YOLO_ENGINE_FLAGS.codex}`);
-    if (yolo && engineName === 'claude') cmd = `${cmd} ${YOLO_ENGINE_FLAGS.claude}`;
+    if (yolo && (engineName === 'claude' || engineName === 'fable')) cmd = `${cmd} ${YOLO_ENGINE_FLAGS.claude}`;
     if (engineName === 'codex') cmd = wrapCodexWithWatchdog(cmd, watchdogPath, watchdogReceiptPath);
     return cmd;
   } finally {
@@ -561,6 +561,25 @@ function detectDeadEngineDispatch(result) {
   return { reason: 'nonzero_exit', exitCode };
 }
 
+function plainDispatchFailureCause(result, failure = {}) {
+  const reason = String(failure.reason || failure.stage || '').trim();
+  const output = dispatchResultOutput(result);
+  if (reason === 'no_output') return 'the engine returned no output';
+  if (/not authenticated|please log in|login required|auth(?:entication)?[ _-]?expired/i.test(output)) {
+    return 'the engine login expired';
+  }
+  if (/spawn[^\n]*enoent|enoent[^\n]*spawn|failed to spawn/i.test(output)) {
+    return 'the engine could not start';
+  }
+  if (reason === 'timeout') return 'the engine timed out';
+  if (reason === 'cancelled') return 'the engine run was cancelled';
+  if (reason === 'unknown') return 'the engine exited without a status';
+  if (reason === 'signalled') return `the engine stopped with ${failure.signal || 'a signal'}`;
+  const detail = String(failure.detail || output || '').trim().split('\n')[0].trim();
+  if (detail) return detail.replace(/[.]+$/, '');
+  return (reason || 'the engine failed').replace(/_/g, ' ');
+}
+
 function recordDispatchEngineHealth(result, failure, root) {
   if (!result || !result.engine) return null;
   const status = failure
@@ -1081,6 +1100,7 @@ module.exports = {
   shipWithRetry,
   shipFailureDetail,
   get FLEET_CAPABLE() { return FLEET_CAPABLE; },
+  get DISPATCH_CAPABLE() { return DISPATCH_CAPABLE; },
   get runFleetFlight() { return runFleetFlight; },
   get focusedCheck() { return focusedCheck; },
   get dispatchCheck() { return dispatchCheck; },
@@ -1122,6 +1142,7 @@ module.exports = {
 // Engines that can edit a repo headlessly. atris-fast (ax) is a chat lane,
 // not a repo worker — it keeps owning normal mission ticks, not fleet builds.
 const FLEET_CAPABLE = ['claude', 'codex', 'cursor', 'devin', 'grok'];
+const DISPATCH_CAPABLE = [...FLEET_CAPABLE, 'fable'];
 
 let receiptSequence = 0;
 function nowStamp() {
@@ -2658,6 +2679,18 @@ async function runFleetFlight({
 // ---------------------------------------------------------------------------
 // T5 — one-command dispatch: `atris engine dispatch <task-id> --engine <name>`
 
+// A claim taken before the engine starts must not stay held if the flight
+// refuses or errors first. Release through the same task plane the claim used.
+function releaseUnstartedDispatchClaim(cli, { taskId, actor, detail }) {
+  const released = cli(['task', 'release', taskId, '--as', actor]);
+  const releasedOk = Boolean(released && released.status === 0);
+  const suffix = releasedOk
+    ? 'claim released, safe to retry'
+    : `claim release failed: ${String(released && (released.stderr || released.stdout) || 'unknown').trim().slice(0, 80)}`;
+  const base = String(detail || '').trim().slice(0, 200);
+  return { released: releasedOk, detail: base ? `${base}. ${suffix}` : suffix };
+}
+
 // The manual version of this loop took 6 Bash calls per task the night this
 // was written: claim, worktree start, prompt file, engine -p, verify, ship.
 // One or more explicit task ids build in parallel isolated worktrees on ONE
@@ -2693,8 +2726,8 @@ async function runDispatchFlight({
   scoutAsk = null,
 } = {}) {
   if (!engine) throw new Error('runDispatchFlight: engine is required');
-  if (!FLEET_CAPABLE.includes(engine)) {
-    throw new Error(`runDispatchFlight: engine "${engine}" cannot build headlessly (capable: ${FLEET_CAPABLE.join(', ')})`);
+  if (!DISPATCH_CAPABLE.includes(engine)) {
+    throw new Error(`runDispatchFlight: engine "${engine}" cannot build headlessly (capable: ${DISPATCH_CAPABLE.join(', ')})`);
   }
   const ids = [...new Set((taskIds || []).map((id) => String(id).trim()).filter(Boolean))];
   if (!ids.length) throw new Error('runDispatchFlight: at least one task id is required');
@@ -2760,51 +2793,71 @@ async function runDispatchFlight({
       log(`    x ${taskId} claim failed`);
       continue;
     }
-    let landingWorktreePath = '';
-    let remoteBoundary = null;
-    if (enforceRemoteBoundary) {
-      remoteBoundary = prepareReviewSandbox({ root, taskId, engine });
-    } else {
-      const started = cli(['worktree', 'start', '--agent', engine, '--task', `dispatch-${taskId.toLowerCase()}`, ...startBaseArgs]);
-      const wt = (started.stdout.match(/next: cd (.+)/) || [])[1];
-      if (!wt) {
-        flight.paused.push({ task: taskId, stage: 'worktree_start', detail: String(started.stderr || '').slice(0, 200) });
-        log(`    ✗ ${taskId} worktree start failed`);
+    try {
+      let landingWorktreePath = '';
+      let remoteBoundary = null;
+      if (enforceRemoteBoundary) {
+        remoteBoundary = prepareReviewSandbox({ root, taskId, engine });
+      } else {
+        const started = cli(['worktree', 'start', '--agent', engine, '--task', `dispatch-${taskId.toLowerCase()}`, ...startBaseArgs]);
+        const wt = (started.stdout.match(/next: cd (.+)/) || [])[1];
+        if (!wt) {
+          const released = releaseUnstartedDispatchClaim(cli, {
+            taskId,
+            actor: taskActor,
+            detail: String(started.stderr || '').slice(0, 200),
+          });
+          flight.paused.push({ task: taskId, stage: 'worktree_start', detail: released.detail });
+          log(`    ✗ ${taskId} worktree start failed`);
+          continue;
+        }
+        landingWorktreePath = wt.trim();
+      }
+      if (enforceRemoteBoundary && (!remoteBoundary || remoteBoundary.ok !== true)) {
+        const released = releaseUnstartedDispatchClaim(cli, {
+          taskId,
+          actor: taskActor,
+          detail: String(remoteBoundary && remoteBoundary.detail || 'could not prepare a sealed review sandbox').slice(-500),
+        });
+        flight.paused.push({
+          task: taskId,
+          stage: 'remote_quarantine',
+          detail: released.detail,
+          worktree: null,
+        });
+        log(`    paused ${taskId} because its sealed review sandbox could not be prepared`);
         continue;
       }
-      landingWorktreePath = wt.trim();
-    }
-    if (enforceRemoteBoundary && (!remoteBoundary || remoteBoundary.ok !== true)) {
-      flight.paused.push({
-        task: taskId,
-        stage: 'remote_quarantine',
-        detail: String(remoteBoundary && remoteBoundary.detail || 'could not prepare a sealed review sandbox').slice(-500),
-        worktree: null,
+      const worktreePath = enforceRemoteBoundary ? remoteBoundary.worktreePath : landingWorktreePath;
+      const startCommit = yolo ? readStartCommit({ worktreePath }) : '';
+      const basePrompt = promptOverride || buildFleetPrompt(task, { worktreePath, yolo });
+      const safetyPrompt = reviewOnly
+        ? `${basePrompt}\n\nSafety boundary: edit and test this checkout only. Do not push, merge, deploy, publish, send messages, change cloud state, install dependencies, or use credentials.`
+        : basePrompt;
+      const trustedPrompt = trustedVerifier
+        ? `${safetyPrompt}\n\nTrusted verifier (run it bare before reporting done): ${trustedVerifier}`
+        : promptOverride;
+      prepared.push({
+        task,
+        taskId,
+        worktreePath,
+        landingWorktreePath,
+        engine,
+        remoteBoundary,
+        remoteMasterBefore: remoteBoundary ? remoteBoundary.protectedMaster : '',
+        startCommit,
+        ...(trustedPrompt ? { prompt: trustedPrompt } : {}),
       });
-      log(`    paused ${taskId} because its sealed review sandbox could not be prepared`);
-      continue;
+      log(`    building ${taskId} in ${path.basename(worktreePath)}`);
+    } catch (err) {
+      const released = releaseUnstartedDispatchClaim(cli, {
+        taskId,
+        actor: taskActor,
+        detail: String(err && err.message || err).slice(0, 200),
+      });
+      flight.paused.push({ task: taskId, stage: 'prepare', detail: released.detail });
+      log(`    ✗ ${taskId} prepare failed`);
     }
-    const worktreePath = enforceRemoteBoundary ? remoteBoundary.worktreePath : landingWorktreePath;
-    const startCommit = yolo ? readStartCommit({ worktreePath }) : '';
-    const basePrompt = promptOverride || buildFleetPrompt(task, { worktreePath, yolo });
-    const safetyPrompt = reviewOnly
-      ? `${basePrompt}\n\nSafety boundary: edit and test this checkout only. Do not push, merge, deploy, publish, send messages, change cloud state, install dependencies, or use credentials.`
-      : basePrompt;
-    const trustedPrompt = trustedVerifier
-      ? `${safetyPrompt}\n\nTrusted verifier (run it bare before reporting done): ${trustedVerifier}`
-      : promptOverride;
-    prepared.push({
-      task,
-      taskId,
-      worktreePath,
-      landingWorktreePath,
-      engine,
-      remoteBoundary,
-      remoteMasterBefore: remoteBoundary ? remoteBoundary.protectedMaster : '',
-      startCommit,
-      ...(trustedPrompt ? { prompt: trustedPrompt } : {}),
-    });
-    log(`    building ${taskId} in ${path.basename(worktreePath)}`);
   }
 
   const dispatch = dispatcher || ((entry) => new Promise((resolve) => {
@@ -2828,6 +2881,10 @@ async function runDispatchFlight({
   }));
   const restaffState = { used: false };
 
+  if (engine === 'fable' && prepared.length) {
+    log(`  fable handoff started: receipt ${path.relative(root, receiptPath)}`);
+  }
+
   const results = await Promise.all(prepared.map((entry) => {
     const startedAtMs = Date.now();
     return dispatchEntryWithRestaff({
@@ -3343,6 +3400,12 @@ async function runDispatchFlight({
   flight.finished_at = new Date().toISOString();
   writeDispatchReceipt(flight, receiptPath, { ids, reviewOnly, enforceRemoteBoundary });
   log('');
+  if (engine === 'fable' && flight.paused.length) {
+    const paused = flight.paused[0];
+    const failed = results.find(({ entry }) => entry.taskId === paused.task);
+    const cause = plainDispatchFailureCause(failed && failed.result, paused);
+    log(`  fable handoff failed: ${cause}. receipt: ${path.relative(root, receiptPath)}`);
+  }
   const completedLabel = reviewOnly ? `${flight.ready.length} proof ready` : `${flight.landed.length} landed`;
   log(`  dispatch over: ${completedLabel}, ${flight.paused.length} paused - receipt: ${path.relative(root, flight.receipt)}`);
   log('');

package/lib/known-commands.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const knownCommands = ['init', 'log', 'logs', 'wish', 'ask', 'approve', 'stop', 'ready', 'check', 'drill', 'dream', 'now', 'goal', 'wtf', 'founder', 'orb', 'radar', 'stream', 'ctop', 'launchpad', 'status', 'analytics', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', '_start', 'plan', 'do', 'review', 'release',
+const knownCommands = ['init', 'log', 'logs', 'wish', 'ask', 'approve', 'stop', 'ready', 'check', 'drill', 'dream', 'now', 'goal', 'wtf', 'founder', 'orb', 'radar', 'who', 'stream', 'ctop', 'launchpad', 'status', 'analytics', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', '_start', 'plan', 'do', 'review', 'release',
                        'activate', '_activate', 'agent', 'team', 'chat', 'fast', 'ax', 'console', 'serve', 'login', 'logout', 'whoami', 'switch', 'use', 'accounts', '_resolve', '_profile-email', '_switch-session', 'shell-init', 'update', 'upgrade', 'version', 'help', 'next', 'atris',
                        'clean', 'close', 'harvest', 'verify', 'recover', 'search', 'scout', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'taste', 'teach', 'plugin', 'experiments', 'bench', 'router', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'watch', 'cloud', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube',
                        'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'decide', 'agents', 'probe', 'worktree', 'land', 'caretaker', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'sync-checkout',

package/lib/task-db.js

@@ -369,8 +369,8 @@ function withTaskDisplayRefs(rows, refRows = rows) {
     const ids = sorted.map(row => row && row.id);
     sorted.forEach((row, index) => {
       refs.set(row.id, {
-        display_id: taskDisplayRef(row, index),
-        legacy_ref: shortestUniqueTaskRef(row.id, ids, 8),
+        display_id: row.display_id || taskDisplayRef(row, index),
+        legacy_ref: row.legacy_ref || shortestUniqueTaskRef(row.id, ids, 8),
       });
     });
   }