atris 3.58.6 → 3.58.7

package/commands/mission.js

@@ -6,6 +6,7 @@ const crypto = require('crypto');
 const readline = require('readline');
 const { spawn, spawnSync } = require('child_process');
 const { hasFlag, readFlag, readIntFlag } = require('../lib/arg-parser');
+const { memberProcessPrompt } = require('../lib/member-context');
 const {
   compactErrorPayload,
   compactSuccessPayload,
@@ -111,6 +112,15 @@ const CODEX_NATIVE_GOAL_CLOSED_STATUSES = new Set(['complete', 'completed', 'ach
 const DEFAULT_LONG_RUN_VERIFIER = 'git diff --check';
 const SLEEP_LENGTH_BUDGET_SECONDS = 3600;
 const HUMAN_BLOCKING_PAUSE_REASONS = new Set(['auth-required', 'model-unavailable', 'rate-limit-exceeded-wall']);
+// Claude prints its logged-out message on stdout ("Invalid API key · Please
+// run /login"), not stderr, so the check has to read the captured result text
+// too or a dead login masquerades as a generic claude-error.
+const MISSION_RUNNER_AUTH_EXPIRED_RE = /not authenticated|please log in|login required|auth(?:entication)? expired|invalid (?:api|connection) key|run \/login/i;
+
+function missionRunnerAuthExpired(...texts) {
+  return texts.some((text) => Boolean(text) && MISSION_RUNNER_AUTH_EXPIRED_RE.test(String(text)));
+}
+
 const MISSION_BUDGET_TIERS = Object.freeze({
   quick: Object.freeze({ max_ticks: 4, requested_seconds: 15 * 60 }),
   long: Object.freeze({ max_ticks: 12, requested_seconds: 60 * 60 }),
@@ -8406,8 +8416,12 @@ function probeClaudeBinary() {
 // Pull unread operator pings off the mission and mark them consumed, so the
 // next tick's prompt carries them exactly once. Pings are how a human talks to
 // an always-on member mid-run: atris member ping <name> "<msg>".
+function pendingMissionPings(mission) {
+  return (Array.isArray(mission.pings) ? mission.pings : []).filter((p) => p && !p.consumed_at);
+}
+
 function consumeMissionPings(mission, cwd) {
-  const pending = (Array.isArray(mission.pings) ? mission.pings : []).filter((p) => p && !p.consumed_at);
+  const pending = pendingMissionPings(mission);
   if (!pending.length) return { mission, pings: [] };
   const consumedAt = stampIso();
   const pings = (mission.pings || []).map((p) => (p && !p.consumed_at ? { ...p, consumed_at: consumedAt } : p));
@@ -8415,7 +8429,8 @@ function consumeMissionPings(mission, cwd) {
   return { mission: saved, pings: pending };
 }
 
-function buildTickPrompt(mission, tickIndex, maxTicks, frozen, pings = []) {
+function buildTickPrompt(mission, tickIndex, maxTicks, frozen, pings = [], cwd = process.cwd()) {
+  const sharedProcess = memberProcessPrompt(cwd);
   const pingLines = pings.length
     ? [
       ``,
@@ -8447,6 +8462,7 @@ function buildTickPrompt(mission, tickIndex, maxTicks, frozen, pings = []) {
     `**Last tick:** ${mission.last_tick_at || 'never'}`,
     ...missionBudgetPromptLines(mission),
     ...checkFeedbackLines,
+    ...(sharedProcess ? ['', sharedProcess] : []),
     ``,
     `## Your task`,
     `Do ONE increment of work toward the stop condition. ONE. No more.`,
@@ -8765,7 +8781,7 @@ function spawnGenericRunnerTick(mission, opts) {
       const finalText = String(stdout || '').trim();
       const errStr = String(stderr || '').slice(-2000);
       const ok = code === 0 && !timedOut && !aborted;
-      const authExpired = /not authenticated|please log in|login required|auth(?:entication)? expired/i.test(errStr);
+      const authExpired = !ok && missionRunnerAuthExpired(errStr, finalText);
       resolve({
         ok,
         brief_id: briefId,
@@ -8940,7 +8956,7 @@ function spawnClaudeTick(mission, opts) {
       updateMissionLockOwner(missionLock, missionLock?.driverPid);
       const ok = code === 0 && !isError && !timedOut && !aborted;
       const errStr = stderr.slice(-2000);
-      const authExpired = /not authenticated|please log in|login required|auth(?:entication)? expired/i.test(errStr);
+      const authExpired = !ok && missionRunnerAuthExpired(errStr, finalText, stdoutBuf);
       resolve({
         ok,
         timedOut,
@@ -9521,6 +9537,9 @@ async function executeMissionRunTicksPhase(context) {
           drill: drillResult,
         };
       } else if (tickAtris2Runner) {
+        // Build before consuming direction or allocating the guard: a shared
+        // process read error must leave operator pings available for retry.
+        const prompt = buildTickPrompt(tickRuntimeMission, tickIdx, effectiveMaxTicks, frozen, pendingMissionPings(mission), cwd);
         let atris2GitGuard = null;
         try {
           atris2GitGuard = prepareMissionGitGuard({ root: cwd, tags: missionProtectedTags(mission, cwd) });
@@ -9541,7 +9560,6 @@ async function executeMissionRunTicksPhase(context) {
           const pingDrain = consumeMissionPings(mission, cwd);
           mission = pingDrain.mission;
           runtimeMission = runtimeView(mission);
-          const prompt = buildTickPrompt(tickRuntimeMission, tickIdx, effectiveMaxTicks, frozen, pingDrain.pings);
           const { runAtris2Turn } = require('./probe');
           const businessId = businessIdForAtris2Mission(tickRuntimeMission, cwd);
           const tickController = new AbortController();
@@ -9593,12 +9611,12 @@ async function executeMissionRunTicksPhase(context) {
           }
         }
       } else {
+        const prompt = buildTickPrompt(tickRuntimeMission, tickIdx, effectiveMaxTicks, frozen, pendingMissionPings(mission), cwd);
         let sessionMode = sessionId ? 'resume' : 'set';
         let useId = sessionId || pendingSessionId;
         const pingDrain = consumeMissionPings(mission, cwd);
         mission = pingDrain.mission;
         runtimeMission = runtimeView(mission);
-        const prompt = buildTickPrompt(tickRuntimeMission, tickIdx, effectiveMaxTicks, frozen, pingDrain.pings);
         const restoreTickRunnerProfile = tickEngineId ? applyMissionRunnerProfile(tickEngineId) : () => {};
         let claudeResult;
         let sessionBusyRetried = false;
@@ -9813,6 +9831,14 @@ async function executeMissionRunTicksPhase(context) {
       const claudeRanTick = Boolean(result.claude) && result.status === 'ran';
       const claudeSessionTicks = claudeRanTick ? Number(mission.claude_session_ticks || 0) + 1 : Number(mission.claude_session_ticks || 0);
       const rotateSessionForContext = claudeRanTick && claudeSessionTicks >= CLAUDE_SESSION_CONTEXT_ROTATE_TICKS;
+      // Heartbeat missions run one tick per invocation, so the in-run ticks
+      // array alone can never see two identical errors. Persist the trailing
+      // same-reason errored count so the breaker below trips across runs.
+      const errorStreakCount = result.status === 'errored' && result.reason
+        ? (latestOnDisk.last_tick_status === 'errored' && latestOnDisk.last_tick_reason === result.reason
+          ? Number(latestOnDisk.error_streak_count || 0) + 1
+          : 1)
+        : 0;
       // Base on latestOnDisk so mid-tick complete proof/completed_at survive.
       mission = saveMission({
         ...latestOnDisk,
@@ -9825,6 +9851,7 @@ async function executeMissionRunTicksPhase(context) {
         last_tick_index: tickIdx,
         last_tick_layer: result.layer,
         last_tick_layer_source: result.layer_source,
+        error_streak_count: errorStreakCount,
         verifier_result: verifierResult || (verifyEach && result.protected_lane_guard && result.protected_lane_guard.allowed === false ? null : latestOnDisk.verifier_result) || null,
         last_check_feedback: verifierResult
           ? extractCheckFeedback(verifierResult)
@@ -9902,9 +9929,12 @@ async function executeMissionRunTicksPhase(context) {
       // is the same trap one step less deterministic: keep retrying and the loop burns every
       // tick + cron firing on it. Halt at two-in-a-row and surface the reason for a human.
       const errStreak = consecutiveSameReasonErrors(ticks);
+      // The in-run ticks array only sees this invocation; the persisted streak
+      // carries identical errors across heartbeat runs of one tick each.
+      const errStreakCount = Math.max(errStreak.count, errStreak.reason ? Number(mission.error_streak_count || 0) : 0);
       // Sleeping Atris2 backends are different: leave the mission running so the
       // next tick or heartbeat can catch the backend after it wakes.
-      if (errStreak.count >= 2 && !missionRunKeepsRetryingError(errStreak.reason)) { pauseReason = `repeated-error:${errStreak.reason}`; break; }
+      if (errStreakCount >= 2 && !missionRunKeepsRetryingError(errStreak.reason)) { pauseReason = `repeated-error:${errStreak.reason}`; break; }
 
       // Sleep until next tick
       let sleepMs = 0;

package/commands/pulse.js

@@ -18,6 +18,7 @@ const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
 const pulse = require('../lib/pulse');
+const rsi = require('../lib/rsi-record');
 const { DEFAULT_CLAUDE_RUNNER_MODEL } = require('../lib/runner-command');
 const { hasFlag } = require('../lib/arg-parser');
 
@@ -267,6 +268,14 @@ function tickCommand(args, root = process.cwd()) {
     orbIngestError,
   }));
 
+  // Dream-RSI: record this tick as one attempt when the workspace has the
+  // recorder. Best-effort; a missing or failing recorder never changes the
+  // tick's outcome. The engine spawns claude-backed runners by default.
+  const rsiLog = (m) => { if (!asJson) process.stderr.write(`rsi: ${m}\n`); };
+  const rsiAttempt = rsi.beginAttempt(root, { lane: rsi.IMPROVE_LANE, engine: 'claude', log: rsiLog });
+  const rsiBefore = rsiAttempt ? rsi.gitSnapshot(root) : null;
+  let rsiOutcome = null;
+
   let engine;
   let verify = { passed: null, cmd: verifyCmd };
   try {
@@ -312,6 +321,14 @@ function tickCommand(args, root = process.cwd()) {
         ? 'no due mission; heartbeat alive (no-op)'
         : `mission ${engine.reason}${changedTail}`;
 
+    rsiOutcome = {
+      status: !engine.ok || verify.passed === false ? 'failed' : producedWork ? 'shipped' : 'nothing',
+      verify: verify.passed === true ? 'pass' : verify.passed === false ? 'fail' : 'skipped',
+      elapsed_s: Math.round(elapsedMs / 100) / 10,
+      engine_calls: 1,
+      reason: String(what || '').slice(0, 200),
+    };
+
     const receipt = pulse.buildPulseReceipt({
       tickIndex,
       phase: 'finished',
@@ -426,11 +443,32 @@ function tickCommand(args, root = process.cwd()) {
       orb_policy_lesson: orbPolicy,
     };
     if (orbIngestError) out.orb_ingest_error = orbIngestError;
+    rsiOutcome = {
+      status: 'failed',
+      verify: 'skipped',
+      elapsed_s: Math.round((Date.now() - startedAt) / 100) / 10,
+      engine_calls: 1,
+      reason: String(err && err.message ? err.message : err).slice(-200),
+    };
     if (!asJson) process.stdout.write(`pulse tick #${tickIndex} crashed: ${out.error}\n`);
     return emit(out, asJson);
   } finally {
     process.removeListener('SIGINT', finishInterrupted);
     process.removeListener('SIGTERM', finishInterrupted);
+    if (rsiAttempt) {
+      const delta = rsi.gitDelta(root, rsiBefore);
+      rsi.finishAttempt(root, rsiAttempt, {
+        commits: delta.commits,
+        files: delta.files,
+        ...(rsiOutcome || {
+          status: 'failed',
+          verify: 'skipped',
+          elapsed_s: Math.round((Date.now() - startedAt) / 100) / 10,
+          engine_calls: 1,
+          reason: 'tick ended without an outcome',
+        }),
+      }, { log: rsiLog });
+    }
     pulse.releaseLock(root);
   }
 }

package/commands/rsi.js

@@ -0,0 +1,156 @@
+'use strict';
+
+// atris rsi - read the Dream-RSI attempt ledger in plain words.
+//
+// Prints trees and attempts by lane, the most recent day's attempts and
+// outcomes, the live policy id, and the last dream receipt. Read-only: it
+// never touches record.py, never writes state, and exits 0 even when the
+// workspace has no ledger yet.
+
+const fs = require('fs');
+const rsi = require('../lib/rsi-record');
+
+function readJsonl(file) {
+  try {
+    return fs.readFileSync(file, 'utf8')
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => { try { return JSON.parse(line); } catch { return null; } })
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function dayOf(node) {
+  return String((node && node.created_at) || '').slice(0, 10);
+}
+
+function collectStatus(root) {
+  const nodes = rsi.latestNodes(root);
+  const lanes = new Map();
+  for (const n of nodes) {
+    const lane = String(n.lane || 'unknown');
+    if (!lanes.has(lane)) {
+      lanes.set(lane, { trees: new Set(), nodes: 0, shipped: 0, failed: 0, nothing: 0, open: 0 });
+    }
+    const l = lanes.get(lane);
+    l.trees.add(String(n.tree_id || ''));
+    l.nodes += 1;
+    const st = n.outcome && n.outcome.status;
+    if (st === 'shipped') l.shipped += 1;
+    else if (st === 'failed') l.failed += 1;
+    else if (st === 'nothing') l.nothing += 1;
+    else l.open += 1; // running / waiting / unlabeled
+  }
+  const days = [...new Set(nodes.map(dayOf).filter(Boolean))].sort();
+  const lastDay = days.length ? days[days.length - 1] : null;
+  const lastAttempts = lastDay ? nodes.filter((n) => dayOf(n) === lastDay) : [];
+  const policyFile = `${root}/atris/rsi/policy.current`;
+  const policy = fs.existsSync(policyFile) ? rsi.currentPolicyId(root) : 'p-0001 (default)';
+  const dreams = readJsonl(rsi.dreamsPath(root));
+  return {
+    lanes,
+    lastDay,
+    lastAttempts,
+    policy,
+    lastDream: dreams.length ? dreams[dreams.length - 1] : null,
+    totalNodes: nodes.length,
+    ledger: rsi.attemptsPath(root),
+  };
+}
+
+function outcomeWord(status, verify) {
+  if (status === 'shipped') return verify === 'pass' ? 'shipped, verify passed' : 'shipped';
+  if (status === 'failed') return 'failed';
+  if (status === 'nothing') return 'found nothing to do';
+  return 'still open';
+}
+
+function formatStatus(s) {
+  const lines = ['rsi attempts ledger', `  ${s.ledger}`, ''];
+  if (!s.totalNodes) {
+    lines.push('  no attempts recorded yet.');
+    lines.push('');
+    lines.push(`  policy: ${s.policy}`);
+    if (s.lastDream) lines.push(`  last dream: ${dreamLine(s.lastDream)}`);
+    else lines.push('  no dreams yet.');
+    return lines.join('\n');
+  }
+  const totalTrees = [...s.lanes.values()].reduce((a, l) => a + l.trees.size, 0);
+  lines.push(`  ${totalTrees} tree${totalTrees === 1 ? '' : 's'}, ${s.totalNodes} attempt${s.totalNodes === 1 ? '' : 's'} across ${s.lanes.size} lane${s.lanes.size === 1 ? '' : 's'}:`);
+  for (const [lane, l] of [...s.lanes.entries()].sort()) {
+    const parts = [];
+    if (l.shipped) parts.push(`${l.shipped} shipped`);
+    if (l.failed) parts.push(`${l.failed} failed`);
+    if (l.nothing) parts.push(`${l.nothing} nothing`);
+    if (l.open) parts.push(`${l.open} open`);
+    lines.push(`    ${lane}: ${l.trees.size} tree${l.trees.size === 1 ? '' : 's'}, ${l.nodes} attempt${l.nodes === 1 ? '' : 's'}${parts.length ? ` (${parts.join(', ')})` : ''}`);
+  }
+  lines.push('');
+  lines.push(`  last night (${s.lastDay}): ${s.lastAttempts.length} attempt${s.lastAttempts.length === 1 ? '' : 's'}`);
+  for (const n of s.lastAttempts.slice(0, 10)) {
+    const reason = String((n.outcome && n.outcome.reason) || '').replace(/\s+/g, ' ').trim().slice(0, 80);
+    lines.push(`    ${n.id}: ${outcomeWord(n.outcome && n.outcome.status, n.outcome && n.outcome.verify)}${reason ? ` - ${reason}` : ''}`);
+  }
+  if (s.lastAttempts.length > 10) lines.push(`    ...and ${s.lastAttempts.length - 10} more`);
+  lines.push('');
+  lines.push(`  policy: ${s.policy}`);
+  lines.push(s.lastDream ? `  last dream: ${dreamLine(s.lastDream)}` : '  no dreams yet.');
+  return lines.join('\n');
+}
+
+function dreamLine(receipt) {
+  const deployed = receipt.deployed ? `deployed ${receipt.deployed}` : `kept ${receipt.current || 'current policy'}`;
+  const reason = String(receipt.reason || '').replace(/\s+/g, ' ').trim().slice(0, 120);
+  return `${receipt.at || '(no date)'} · ${deployed}${reason ? ` · ${reason}` : ''}`;
+}
+
+function showHelp() {
+  console.log(`atris rsi - read the Dream-RSI attempt ledger
+
+Usage:
+  atris rsi            same as status
+  atris rsi status     trees + attempts by lane, last night's outcomes, policy, last dream
+  atris rsi status --json   machine-readable status
+
+Read-only. State lives in .atris/state/rsi/ (or $ATRIS_RSI_STATE).`);
+}
+
+function run(argv = []) {
+  const args = Array.isArray(argv) ? argv : [];
+  if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
+    showHelp();
+    return 0;
+  }
+  const sub = args[0] && !args[0].startsWith('-') ? args[0] : 'status';
+  if (sub !== 'status') {
+    console.log(`unknown rsi subcommand: ${sub}`);
+    showHelp();
+    return 2;
+  }
+  const root = process.cwd();
+  const s = collectStatus(root);
+  if (args.includes('--json')) {
+    const lanes = {};
+    for (const [lane, l] of s.lanes.entries()) {
+      lanes[lane] = { trees: l.trees.size, nodes: l.nodes, shipped: l.shipped, failed: l.failed, nothing: l.nothing, open: l.open };
+    }
+    console.log(JSON.stringify({
+      ok: true,
+      ledger: s.ledger,
+      total_nodes: s.totalNodes,
+      lanes,
+      last_day: s.lastDay,
+      last_day_attempts: s.lastAttempts.length,
+      policy: s.policy,
+      last_dream: s.lastDream,
+    }));
+    return 0;
+  }
+  console.log(formatStatus(s));
+  return 0;
+}
+
+module.exports = { run, collectStatus, formatStatus };

package/commands/task.js

@@ -253,6 +253,7 @@ atris task - durable local task state (SQLite, gitignored)
                                            Sweep off-roadmap/duplicate work as archived (not failed);
                                            --from-failed opts in to relabel a fail-closed row (never done)
   atris task clear-done [--before <days>] [--dry-run] [--json]  Archive completed rows, oldest first
+  atris task keep [--json]                 Put away finished and untouched work, then refresh the list
   atris task reap-mission-blockers [--json] Close blocker rows whose missions are complete or stopped
   atris task relabel-archived [--dry-run|--apply]
                                            One-time OBL-1622 migration: relabel June-10 backlog-reset rows failed -> archived
@@ -6416,7 +6417,7 @@ function compactTechnicalDetails(task, formatTitle = value => value) {
 }
 
 function taskDayGroups(tasks, { now = Date.now() } = {}) {
-  const active = tasks.filter(task => task.status !== 'done');
+  const active = tasks.filter(task => task.status !== 'done' && task.status !== 'archived');
   const staleFailed = [];
   const visible = [];
   for (const task of active) {
@@ -6446,7 +6447,43 @@ function taskDayGroups(tasks, { now = Date.now() } = {}) {
   return { groups: grouped, staleFailed };
 }
 
+function refreshKeptTaskList(cwd = process.cwd()) {
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  writeDefaultProjection(taskDb, db);
+  autoRenderTodoFromDb(cwd);
+}
+
+function keptCount(result) {
+  return (result && result.put_away ? result.put_away.length : 0)
+    + (result && result.reaped ? result.reaped.length : 0);
+}
+
+function cmdKeep(args) {
+  const result = require('../lib/task-list-keeper').keepWorkspaceTaskList(process.cwd());
+  if (keptCount(result)) refreshKeptTaskList(process.cwd());
+  const count = keptCount(result);
+  if (wantsJson(args)) {
+    printJson({
+      ok: true,
+      action: 'keep',
+      count,
+      put_away: result.put_away,
+      reaped: result.reaped,
+    });
+    return;
+  }
+  if (!count) {
+    console.log('task list is current. nothing to put away.');
+    return;
+  }
+  const noun = count === 1 ? 'item' : 'items';
+  console.log(`put away ${count} ${noun} that were finished or sitting still.`);
+}
+
 function cmdDay(args) {
+  const kept = require('../lib/task-list-keeper').keepWorkspaceTaskList(process.cwd());
+  if (keptCount(kept)) autoRenderTodoFromDb(process.cwd());
   const all = hasFlag(args, '--all');
   const full = hasFlag(args, '--full');
   const everywhere = taskScopeEverywhere(args);
@@ -13321,6 +13358,7 @@ async function runTaskCommand(args) {
     case 'fail':   return cmdDone([...rest, '--failed']);
     case 'archive': return cmdArchive(rest);
     case 'clear-done': return cmdClearDone(rest);
+    case 'keep': return cmdKeep(rest);
     case 'reap-mission-blockers':
     case 'reap-blockers':
       return cmdReapMissionBlockers(rest);
@@ -13425,6 +13463,8 @@ module.exports = {
   delegateTask,
   AGENT_ENV_MARKERS,
   autoRenderTodoFromDb,
+  refreshKeptTaskList,
+  keptCount,
   projectionMissions,
   projectionWishes,
   taskBoardViewModel,

package/commands/workflow.js

@@ -21,6 +21,15 @@ const { loadContext } = require('../lib/state-detection');
 const { buildToolResultBody } = require('../lib/tool-result-encode');
 const { commitReviewLearning } = require('./learn');
 
+function appendReviewLearningToJournal(journalContent, learning) {
+  const text = String(journalContent || '').replace(/\r\n/g, '\n');
+  const note = String(learning || '');
+  if (text.includes('## Notes')) {
+    return text.replace(/## Notes\n/, `## Notes\n${note}\n`);
+  }
+  return `${text}\n## Notes\n${note}\n`;
+}
+
 function wrapWorkflowText(text, width = 76) {
   const normalized = String(text || '').replace(/\s+/g, ' ').trim();
   if (!normalized) return [''];
@@ -1775,12 +1784,7 @@ async function reviewAtris() {
           const timestamp = new Date().toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', hour12: false });
           const learning = `- ${timestamp} \u2014 ${answer.trim()}`;
 
-          // Find or create ## Notes section
-          if (journalContent.includes('## Notes')) {
-            journalContent = journalContent.replace(/## Notes\n/, `## Notes\n${learning}\n`);
-          } else {
-            journalContent += `\n## Notes\n${learning}\n`;
-          }
+          journalContent = appendReviewLearningToJournal(journalContent, learning);
 
           fs.writeFileSync(logFile, journalContent);
           console.log('');
@@ -1893,6 +1897,7 @@ module.exports = {
   planAtris,
   doAtris,
   reviewAtris,
+  appendReviewLearningToJournal,
   renderReviewMinute,
   executorAgentPrompt,
   executorDispatchForTask,

package/commands/youtube.js

@@ -283,6 +283,51 @@ function parseVttTimestampMs(value) {
   return ((hours * 3600) + (minutes * 60) + seconds) * 1000 + millis;
 }
 
+function parseCleanTimestampMs(value) {
+  const match = String(value || '').trim().match(/^(?:(\d{1,2}):)?(\d{1,2}):(\d{2})$/);
+  if (!match) return null;
+  const hours = Number(match[1] || 0);
+  const minutes = Number(match[2] || 0);
+  const seconds = Number(match[3] || 0);
+  if (![hours, minutes, seconds].every(Number.isFinite)) return null;
+  if (minutes > 59 || seconds > 59) return null;
+  return ((hours * 3600) + (minutes * 60) + seconds) * 1000;
+}
+
+function parseCleanTranscriptCues(raw) {
+  const cues = [];
+  let startMs = 0;
+  let sawStamp = false;
+  const pending = [];
+  const flush = () => {
+    const text = pending.join(' ').replace(/\s+/g, ' ').trim();
+    pending.length = 0;
+    if (!text) return;
+    const cue = { startMs, text };
+    if (cues.length && cues[cues.length - 1].text === cue.text && cues[cues.length - 1].startMs === cue.startMs) {
+      return;
+    }
+    cues.push(cue);
+  };
+  for (const line of String(raw).split(/\r?\n/)) {
+    const stripped = line.trim();
+    if (!stripped) continue;
+    const stamp = stripped.match(/^\[(\d{1,2}:\d{2}(?::\d{2})?)\]$/);
+    if (stamp) {
+      flush();
+      const parsed = parseCleanTimestampMs(stamp[1]);
+      if (parsed != null) {
+        startMs = parsed;
+        sawStamp = true;
+      }
+      continue;
+    }
+    pending.push(stripped.replace(/<[^>]+>/g, ''));
+  }
+  flush();
+  return sawStamp && cues.length ? cues : [];
+}
+
 function fetchCaptionText(urlString, redirects = 0) {
   if (!captionHostAllowed(urlString)) {
     return Promise.resolve(null);
@@ -380,7 +425,7 @@ function parseCaptionCues(raw) {
     return cues;
   }
 
-  return [];
+  return parseCleanTranscriptCues(raw);
 }
 
 function parseCaptionText(raw) {
@@ -415,7 +460,14 @@ function parseCaptionText(raw) {
 }
 
 function parseYtDlpInfoJson(result) {
-  const raw = String((result && result.stdout) || '').trim();
+  const kept = [];
+  for (const line of String((result && result.stdout) || '').split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (/^(WARNING|ERROR|INFO)\b/i.test(trimmed)) continue;
+    kept.push(trimmed);
+  }
+  const raw = kept.join('\n').trim();
   if (!raw) return null;
   try {
     const info = JSON.parse(raw);
@@ -426,7 +478,7 @@ function parseYtDlpInfoJson(result) {
 }
 
 function localCaptionNames(id) {
-  // scripts/det/ytnotes keeps the same VTT names (not clean.txt).
+  // scripts/det/ytnotes keeps these VTT names plus leftover yt_<id>.clean.txt.
   return [
     `yt_${id}.en.vtt`,
     `yt_${id}.en-orig.vtt`,
@@ -765,6 +817,10 @@ function applySidecarRel(id) {
   return applyGate.applySidecarRel('youtube', id);
 }
 
+function notesApplyRel(id) {
+  return applyGate.applySidecarRel('notes', experimentIdToken(id));
+}
+
 function notesExperimentSlug(id) {
   return `notes-${experimentIdToken(id)}`;
 }
@@ -814,7 +870,7 @@ function saveRichNotes(url, deps = {}) {
     url,
     lesson,
     slug: id ? notesExperimentSlug(id) : null,
-    applyRel: id ? applySidecarRel(id) : null,
+    applyRel: id ? notesApplyRel(id) : null,
   });
   return { thin: false, brief, packRel, lesson };
 }
@@ -826,7 +882,7 @@ function ensureNotesApply({ cwd, url, packRel, now, output } = {}) {
   return applyGate.ensureApply({
     cwd,
     source: url,
-    rel: id ? applySidecarRel(id) : null,
+    rel: id ? notesApplyRel(id) : null,
     now,
     output,
     incompleteMessage: slug
@@ -907,6 +963,7 @@ function unsaveYoutubeNotes(target, deps = {}) {
   };
   add(briefRel);
   add(applyRel);
+  add(notesApplyRel(id));
   for (const section of sections) {
     add(teachBriefRel(id, section));
     add(applySidecarRel(`${id}-s${section}`));
@@ -959,6 +1016,7 @@ function ensureProcessApply({ cwd, url, now, output } = {}) {
     output,
     incompleteMessage: PROCESS_APPLY_MESSAGE,
     required: true,
+    human: true,
   });
 }
 
@@ -1455,15 +1513,22 @@ function channelVideosUrl(channel) {
   return `${base}/videos`;
 }
 
+function looksLikeFlatVideoId(id) {
+  const text = String(id || '');
+  if (/^(NA|None)$/i.test(text)) return false;
+  return /^[A-Za-z0-9_-]+$/.test(text);
+}
+
 function parseFlatPlaylist(stdout) {
   const videos = [];
   for (const line of String(stdout || '').split(/\r?\n/)) {
     const trimmed = line.trim();
     if (!trimmed || !trimmed.includes('|')) continue;
+    if (/^(WARNING|ERROR|INFO)\b/i.test(trimmed)) continue;
     const idx = trimmed.indexOf('|');
     const id = trimmed.slice(0, idx).trim();
     const title = trimmed.slice(idx + 1).trim();
-    if (id && id !== 'NA') videos.push({ id, title });
+    if (looksLikeFlatVideoId(id)) videos.push({ id, title });
   }
   return videos;
 }
@@ -1744,6 +1809,7 @@ function defaultPlaylistExpander(playlistUrl, deps = {}) {
   const result = spawn('yt-dlp', [
     '--no-update',
     '--flat-playlist',
+    '--no-warnings',
     '--print',
     '%(id)s|%(title)s',
     playlistUrl,
@@ -1938,7 +2004,7 @@ function runYoutubeNotesBatch({ urls, engine, save, json } = {}, deps = {}) {
     }));
     const baseline = proveSavedLearnerBaseline({
       cwd: deps.cwd || process.cwd(),
-      applyRel: id ? applySidecarRel(id) : null,
+      applyRel: id ? notesApplyRel(id) : null,
       lesson,
       output,
       json: asJson,
@@ -1989,7 +2055,7 @@ function runSingleYoutubeNotes(url, engine, deps = {}) {
   const id = videoIdFromUrl(url);
   const baseline = proveSavedLearnerBaseline({
     cwd,
-    applyRel: id ? applySidecarRel(id) : null,
+    applyRel: id ? notesApplyRel(id) : null,
     lesson: saved.lesson,
     output,
     json: deps.json === true,
@@ -2129,10 +2195,12 @@ function parseSearchStdout(stdout = '') {
   for (const line of String(stdout || '').split(/\r?\n/)) {
     const trimmed = line.trim();
     if (!trimmed || !trimmed.includes('|')) continue;
+    if (/^(WARNING|ERROR|INFO)\b/i.test(trimmed)) continue;
     const parts = trimmed.split(/\s*\|\s*/).map((part) => part.trim());
     if (parts.length < 5) continue;
     const url = parts[parts.length - 1];
     if (!/^https?:\/\/(?:www\.)?(?:youtube\.com\/|youtu\.be\/)/i.test(url)) continue;
+    if (!looksLikeFlatVideoId(videoIdFromUrl(url))) continue;
     const row = {
       title: parts[0] || '',
       channel: parts[1] || '',