atris 3.58.6 → 3.58.8

package/commands/stream.js

@@ -293,6 +293,31 @@ function pushEvent(events, input) {
   if (event) events.push({ ...event, key: eventKey(event) });
 }
 
+// When timestamps match, state snapshots precede receipts, then landing summaries.
+const STREAM_SOURCE_RANK = {
+  task: 20,
+  task_episode: 30,
+  scorecard: 40,
+  mission_event: 50,
+  mission_state: 60,
+  mission_receipt: 70,
+  mission_landing: 80,
+  worktree: 85,
+  landing: 90,
+  state: 10,
+};
+
+function compareStreamEvents(a, b) {
+  const byMs = a.ms - b.ms;
+  if (byMs) return byMs;
+  const rankA = STREAM_SOURCE_RANK[a.source] ?? 55;
+  const rankB = STREAM_SOURCE_RANK[b.source] ?? 55;
+  if (rankA !== rankB) return rankA - rankB;
+  const byKey = String(a.key || '').localeCompare(String(b.key || ''));
+  if (byKey) return byKey;
+  return String(a.event || '').localeCompare(String(b.event || ''));
+}
+
 function statePaths(root) {
   const stateDir = path.join(root, '.atris', 'state');
   return {
@@ -455,7 +480,6 @@ function collectRunReceiptEvents(root, deps, events) {
 
 function candidateWorktreeDirs(root, deps) {
   const dirs = new Set([
-    path.resolve(root, '..', '.agent-worktrees'),
     path.join(path.dirname(root), '.agent-worktrees', path.basename(root)),
   ]);
   const sidecar = readJson(statePaths(root).sidecar, deps, null);
@@ -606,7 +630,7 @@ function collectStreamEvents({ root = process.cwd(), sinceMs = 0, agent = '', no
     if (wantedAgent && event.agent.toLowerCase() !== wantedAgent) continue;
     byKey.set(event.key, event);
   }
-  return [...byKey.values()].sort((a, b) => (a.ms - b.ms) || a.event.localeCompare(b.event));
+  return [...byKey.values()].sort(compareStreamEvents);
 }
 
 function waitingOnOperator(tasks) {
@@ -841,6 +865,7 @@ function streamCommand(args = [], deps = defaultDeps()) {
 module.exports = {
   collectSnapshot,
   collectStreamEvents,
+  compareStreamEvents,
   createStreamState,
   parseArgs,
   parseSince,

package/commands/study.js

@@ -15,6 +15,7 @@ const fs = require('fs');
 const path = require('path');
 const http = require('http');
 const { spawn, spawnSync } = require('child_process');
+const { resolveBackendRoot } = require('../utils/backend-root');
 
 const FEED_URL = 'http://localhost:8777';
 const FEED_STATS_URL = `${FEED_URL}/api/stats`;
@@ -91,15 +92,19 @@ function parseArgs(argv = []) {
 }
 
 function resolveStudyRoot(cwd = process.cwd()) {
-  const candidates = [
-    process.env.ATRIS_STUDY_ROOT,
-    process.env.ATRIS_BACKEND_ROOT,
-    path.join(path.resolve(cwd), 'atris', 'study'),
-  ].filter(Boolean);
-  for (const root of candidates) {
-    const resolved = path.resolve(String(root));
-    if (fs.existsSync(resolved)) return resolved;
-  }
+  if (process.env.ATRIS_STUDY_ROOT) {
+    const explicit = path.resolve(process.env.ATRIS_STUDY_ROOT);
+    if (fs.existsSync(explicit) && fs.statSync(explicit).isDirectory()) return explicit;
+  }
+  // Same order as before: an explicitly set backend root wins over the local folder.
+  if (process.env.ATRIS_BACKEND_ROOT) {
+    const envBackend = path.resolve(process.env.ATRIS_BACKEND_ROOT);
+    if (fs.existsSync(envBackend)) return envBackend;
+  }
+  const local = path.join(path.resolve(cwd), 'atris', 'study');
+  if (fs.existsSync(local) && fs.statSync(local).isDirectory()) return local;
+  const backend = resolveBackendRoot(cwd);
+  if (backend) return backend;
   return null;
 }
 
@@ -697,6 +702,7 @@ async function run(argv = []) {
 
 module.exports = {
   run,
+  resolveStudyRoot,
   parseArgs,
   showHelp,
   wrapText,

package/commands/sync.js

@@ -615,7 +615,7 @@ Detect: Project has \`atris/\` folder with MAP.md, TODO.md, PERSONA.md
 Commands: plan → do → review
 
 Key behaviors:
-- Read PERSONA.md (3-4 sentences, ASCII visuals)
+- Read PERSONA.md (MAP.md first, plain words, lead with the outcome)
 - Check MAP.md for file:line refs
 - Use \`atris task\` for claims, proof, ready, and accept
 - Give every task a plain first layer: what changes, why it matters, and what

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
@@ -633,6 +634,12 @@ function goldenPathMissionXpTask(task) {
     && /\b(?:golden[- ]path|zero[- ]knowledge|zero[- ]papercuts?|fresh[- ](?:laptop|environment|install|home)|self[- ]landed)\b/i.test(text);
 }
 
+// A receipt that cannot be read drops out of review evidence; name it under
+// ATRIS_DEBUG so the gap is findable, matching lib/todo.js.
+function debugUnreadableReceipt(rel, err) {
+  if (process.env.ATRIS_DEBUG) console.error(`[task] receipt unreadable, skipped: ${rel}: ${err && err.message}`);
+}
+
 function receiptTextForProof(proof, root = process.cwd()) {
   const chunks = [];
   const pattern = new RegExp(RECEIPT_PATH_PATTERN.source, 'g');
@@ -651,7 +658,9 @@ function receiptTextForProof(proof, root = process.cwd()) {
         last_landing: parsed.last_landing || null,
         summary: parsed.summary || null,
       }).slice(0, 12000));
-    } catch {}
+    } catch (err) {
+      debugUnreadableReceipt(rel, err);
+    }
   }
   return chunks.join(' ');
 }
@@ -671,7 +680,10 @@ function missionReceiptResultForProof(task, proof, root = process.cwd()) {
     try {
       const parsed = JSON.parse(fs.readFileSync(path.resolve(root, rel), 'utf8'));
       landing = parsed?.result?.landing || parsed?.landing || parsed?.last_landing || null;
-    } catch { continue; }
+    } catch (err) {
+      debugUnreadableReceipt(rel, err);
+      continue;
+    }
     const changed = String(landing?.changed || landing?.happened || '').replace(/\s+/g, ' ').trim();
     if (!changed) continue;
     if (/\brecorded tick \d+\.?$/i.test(changed) || /^recorded a proof heartbeat\b/i.test(changed)) continue;
@@ -6416,7 +6428,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 +6458,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 +13369,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 +13474,8 @@ module.exports = {
   delegateTask,
   AGENT_ENV_MARKERS,
   autoRenderTodoFromDb,
+  refreshKeptTaskList,
+  keptCount,
   projectionMissions,
   projectionWishes,
   taskBoardViewModel,

package/commands/workflow.js

@@ -21,6 +21,19 @@ const { loadContext } = require('../lib/state-detection');
 const { buildToolResultBody } = require('../lib/tool-result-encode');
 const { commitReviewLearning } = require('./learn');
 
+function reviewLearningLine(timestamp, answer) {
+  return `- ${timestamp} - ${String(answer).trim().replace(/\s*\u2014\s*/g, ', ')}`;
+}
+
+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 [''];
@@ -1773,14 +1786,9 @@ async function reviewAtris() {
         if (fs.existsSync(logFile)) {
           let journalContent = fs.readFileSync(logFile, 'utf8');
           const timestamp = new Date().toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', hour12: false });
-          const learning = `- ${timestamp} \u2014 ${answer.trim()}`;
+          const learning = reviewLearningLine(timestamp, answer);
 
-          // 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 +1901,8 @@ module.exports = {
   planAtris,
   doAtris,
   reviewAtris,
+  appendReviewLearningToJournal,
+  reviewLearningLine,
   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] || '',

package/lib/apply-gate.js

@@ -26,6 +26,17 @@ function isFilledApply(fields) {
   return !empty(fields.change) && !empty(fields.receipt);
 }
 
+function isLearnerKeepApply(fields) {
+  const change = String((fields && fields.change) || '');
+  const receipt = String((fields && fields.receipt) || '');
+  return /^apply\s+atris\/experiments\//i.test(change)
+    || /keep only if measure\.py moves 0/.test(receipt);
+}
+
+function isFilledHumanApply(fields) {
+  return isFilledApply(fields) && !isLearnerKeepApply(fields);
+}
+
 function applySlug(text) {
   const slug = String(text || '')
     .toLowerCase()
@@ -46,7 +57,7 @@ function readApplyReceipt({ cwd, rel } = {}) {
   return { rel, text: fs.readFileSync(abs, 'utf8') };
 }
 
-function writeApplyStub({ cwd, source, rel, now, change, receipt, journalLine } = {}) {
+function writeApplyStub({ cwd, source, rel, now, change, receipt, journalLine, force } = {}) {
   try {
     if (!rel || !cwd) return null;
     const wikiDir = path.join(cwd, 'atris', 'wiki');
@@ -56,7 +67,7 @@ function writeApplyStub({ cwd, source, rel, now, change, receipt, journalLine }
     fs.mkdirSync(path.dirname(abs), { recursive: true });
     const changeText = change || 'fill this';
     const receiptText = receipt || 'fill this';
-    let shouldWrite = !fs.existsSync(abs);
+    let shouldWrite = force === true || !fs.existsSync(abs);
     if (!shouldWrite && change && receipt) {
       shouldWrite = !isFilledApply(parseApplyFields(fs.readFileSync(abs, 'utf8')));
     }
@@ -86,11 +97,16 @@ function writeApplyStub({ cwd, source, rel, now, change, receipt, journalLine }
 
 function ensureApply({
   cwd, source, rel, now, output, incompleteMessage, required = true, change, receipt, journalLine,
+  human = false,
 } = {}) {
   const print = typeof output === 'function' ? output : (line = '') => console.error(line);
   const existing = readApplyReceipt({ cwd, rel });
-  if (existing && isFilledApply(parseApplyFields(existing.text))) return 0;
-  if (!(required && existing)) writeApplyStub({ cwd, source, rel, now, change, receipt, journalLine });
+  const fields = existing ? parseApplyFields(existing.text) : null;
+  const keepSidecar = Boolean(human && fields && isLearnerKeepApply(fields));
+  if (existing && isFilledApply(fields) && !keepSidecar) return 0;
+  if (!(required && existing) || keepSidecar) {
+    writeApplyStub({ cwd, source, rel, now, change, receipt, journalLine, force: keepSidecar });
+  }
   print(incompleteMessage);
   return required ? 2 : 0;
 }
@@ -112,4 +128,6 @@ module.exports = {
   ensureApply,
   ephemeralApplyMessage,
   hintEphemeralApply,
+  isFilledHumanApply,
+  isLearnerKeepApply,
 };

package/lib/codex-flight.js

@@ -1,10 +1,12 @@
 'use strict';
 
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
 const { spawn, spawnSync } = require('child_process');
 
-const CODEX_COMPANION = '/Users/keshavrao/.claude/plugins/cache/openai-codex/codex/1.0.4/scripts/codex-companion.mjs';
+// Worktree flights need full file access to edit and ship the requested repo.
+const FLIGHT_SANDBOX = 'danger-full-access';
 const CONTRACT = "CRITICAL: complete the entire job in this single run; never end your reply on a plan. Do NOT run any atris boot/brain/state commands; the only atris commands allowed are 'atris worktree guard' and 'atris worktree ship'.";
 const COAUTHOR = 'Co-authored-by: Atris <299057014+atris-builder[bot]@users.noreply.github.com>';
 
@@ -96,12 +98,30 @@ function parseTaskId(stdout) {
   return asMatch ? asMatch[1] : '';
 }
 
-function spawnCodex(worktreePath, prompt) {
+function resolveCodexCompanion() {
+  if (process.env.ATRIS_CODEX_COMPANION) {
+    const override = path.resolve(process.env.ATRIS_CODEX_COMPANION);
+    return fs.existsSync(override) && fs.statSync(override).isFile() ? override : null;
+  }
+  const cache = path.join(os.homedir(), '.claude', 'plugins', 'cache', 'openai-codex', 'codex');
+  if (!fs.existsSync(cache)) return null;
+  const versions = fs.readdirSync(cache, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
+  for (const version of versions) {
+    const script = path.join(cache, version, 'scripts', 'codex-companion.mjs');
+    if (fs.existsSync(script) && fs.statSync(script).isFile()) return script;
+  }
+  return null;
+}
+
+function spawnCodex(worktreePath, prompt, companion) {
   return new Promise((resolve, reject) => {
-    const argv = [CODEX_COMPANION, 'task', '--background', '--write', prompt];
+    const argv = [companion, 'task', '--background', '--write', prompt];
     const child = spawn('node', argv, {
       cwd: worktreePath,
-      env: { ...process.env, CODEX_COMPANION_SANDBOX: 'danger-full-access' },
+      env: { ...process.env, CODEX_COMPANION_SANDBOX: FLIGHT_SANDBOX },
       stdio: ['ignore', 'pipe', 'pipe'],
     });
     let stdout = '';
@@ -143,12 +163,15 @@ async function dispatchCodexFlight({ repoPath, slug, brief, verifyCmd, dryRun =
     return { dryRun: true, prompt };
   }
 
+  const companion = resolveCodexCompanion();
+  if (!companion) throw new Error('codex companion not found. set ATRIS_CODEX_COMPANION to its script path.');
   runWorktreeAdd(repo.repoPath, branch, worktreePath);
-  const task = await spawnCodex(worktreePath, prompt);
+  const task = await spawnCodex(worktreePath, prompt, companion);
   return { taskId: task.taskId, worktreePath, branch };
 }
 
 module.exports = {
   dispatchCodexFlight,
   buildPrompt,
+  resolveCodexCompanion,
 };

package/lib/daily-log.js

@@ -0,0 +1,88 @@
+'use strict';
+
+// Two-level daily logging. Member logs (atris/team/<member>/logs/<date>.md)
+// keep the detailed workstream: claims, notes, result receipts, completions.
+// The master journal (atris/logs/<YYYY>/<date>.md) stays curated and receives
+// only consequential entries: terminal task events and explicitly major
+// updates such as decisions, handoffs, and shipped work.
+
+const fs = require('fs');
+const path = require('path');
+
+function todayLogName(now = new Date()) {
+  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}.md`;
+}
+
+function logStamp(now = new Date()) {
+  return now.toTimeString().slice(0, 5);
+}
+
+function compactLogText(value, max = 240) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (!text) return '';
+  return text.length > max ? `${text.slice(0, Math.max(0, max - 3)).trim()}...` : text;
+}
+
+function logFieldRows(fields) {
+  return Object.entries(fields)
+    .filter(([, value]) => value !== undefined && value !== null && value !== '')
+    .map(([key, value]) => `- ${key}: ${compactLogText(value, 500)}`);
+}
+
+function appendDailyEntry(logPath, title, fields) {
+  fs.mkdirSync(path.dirname(logPath), { recursive: true });
+  fs.appendFileSync(logPath, [
+    `## ${logStamp()} · ${title}`,
+    ...logFieldRows(fields),
+    '',
+  ].join('\n'), 'utf8');
+  return logPath;
+}
+
+function memberSlug(root, member) {
+  const slug = String(member || '').trim();
+  if (!/^[A-Za-z0-9._-]+$/.test(slug)) return null;
+  if (!fs.existsSync(path.join(root, 'atris', 'team', slug, 'MEMBER.md'))) return null;
+  return slug;
+}
+
+function appendMemberDailyEntry(root, member, title, fields) {
+  const slug = memberSlug(root, member);
+  if (!slug || !fs.existsSync(path.join(root, 'atris'))) return null;
+  const logPath = path.join(root, 'atris', 'team', slug, 'logs', todayLogName());
+  appendDailyEntry(logPath, title, { ...fields, member: slug });
+  return logPath;
+}
+
+function appendMasterDailyEntry(root, title, fields) {
+  if (!fs.existsSync(path.join(root, 'atris'))) return null;
+  const logName = todayLogName();
+  const logPath = path.join(root, 'atris', 'logs', logName.slice(0, 4), logName);
+  appendDailyEntry(logPath, title, fields);
+  return logPath;
+}
+
+// Notes a person deliberately escalates to the day record. Anything else stays
+// in the member's own log so the master journal does not become a transcript.
+const MASTER_NOTE = /^(decision|decided|milestone|handoff|shipped|launched|landed|blocked)\b\s*[:\-]/i;
+
+function noteTitle(content) {
+  const key = String(content || '').trim().match(/^([a-z]+)\s*[:\-]/i);
+  const word = key ? key[1].toLowerCase() : '';
+  if (word === 'decision' || word === 'decided') return 'Task decision';
+  if (word === 'handoff') return 'Task handoff';
+  if (word === 'shipped' || word === 'launched' || word === 'landed') return 'Task shipped';
+  if (word === 'blocked') return 'Task blocked';
+  if (word === 'milestone') return 'Task milestone';
+  return 'Task update';
+}
+
+module.exports = {
+  todayLogName,
+  compactLogText,
+  memberSlug,
+  appendMemberDailyEntry,
+  appendMasterDailyEntry,
+  MASTER_NOTE,
+  noteTitle,
+};