atris 3.68.2 → 3.68.3

package/lib/member-alive.js

@@ -130,7 +130,7 @@ function runAliveTick(name, opts = {}) {
   }
 
   const wake = runCli(atrisBin, [
-    'member', 'wake', name, '--json',
+    'member', 'wake', name, '--json', '--plan',
     ...(opts.force ? ['--force'] : []),
   ], { cwd, timeoutMs: 120000 });
   tick.wake = wake;

package/lib/member-approval.js

@@ -0,0 +1,153 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// MEMBER.md frontmatter can carry `approval-required: [merge, delete]` (the
+// scaffold nests it under `permissions:`). Nothing in the CLI ever read it.
+// This reader is deliberately tolerant: inline list, block list, nested or
+// top-level, quotes optional. It returns [] for anything it cannot read, so a
+// malformed file never blocks a mission, it just seeds no ask.
+
+const MEMBER_SLUG = /^[a-zA-Z0-9._-]+$/;
+
+function frontmatterOf(text) {
+  const match = String(text || '').match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  return match ? match[1].split(/\r?\n/) : null;
+}
+
+function cleanItem(value) {
+  return String(value || '').trim().replace(/^["']|["']$/g, '').trim();
+}
+
+function parseApprovalRequired(text) {
+  const lines = frontmatterOf(text);
+  if (!lines) return [];
+  const index = lines.findIndex((line) => /^\s*approval-required\s*:/.test(line));
+  if (index < 0) return [];
+  const rest = lines[index].replace(/^\s*approval-required\s*:/, '').replace(/\s+#.*$/, '').trim();
+  let items = [];
+  if (rest.startsWith('[')) {
+    const end = rest.lastIndexOf(']');
+    items = rest.slice(1, end > 0 ? end : undefined).split(',');
+  } else if (rest) {
+    items = [rest];
+  } else {
+    const indent = lines[index].match(/^\s*/)[0].length;
+    for (let i = index + 1; i < lines.length; i += 1) {
+      const item = lines[i].match(/^(\s*)-\s+(.+)$/);
+      if (!item || item[1].length < indent) break;
+      items.push(item[2].replace(/\s+#.*$/, ''));
+    }
+  }
+  return Array.from(new Set(items.map(cleanItem).filter(Boolean)));
+}
+
+function memberApprovalRequired(owner, root = process.cwd()) {
+  const slug = String(owner || '').trim();
+  if (!slug || !MEMBER_SLUG.test(slug)) return [];
+  try {
+    const file = path.join(root, 'atris', 'team', slug, 'MEMBER.md');
+    if (!fs.existsSync(file)) return [];
+    return parseApprovalRequired(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return [];
+  }
+}
+
+// Categories are action classes ("delete", "publish"), not mission-level
+// gates. Seeding an ask for every listed category would stop every mission of
+// a member whose template lists any (the shipped executor lists delete), so a
+// category only seeds an ask when the mission objective names it. The head
+// word of the category is matched as a stem: "delete" catches deleting/deletion,
+// "destructive-file-action" catches destructive, "spend" catches spending.
+function wordStem(word) {
+  const head = String(word || '').toLowerCase();
+  if (head.length < 3) return '';
+  return head.length > 4 ? head.replace(/(e|es|s|ing|ed)$/, '') : head;
+}
+
+function categoryStem(category) {
+  return wordStem(String(category || '').toLowerCase().split(/[^a-z0-9]+/).filter(Boolean)[0] || '');
+}
+
+// A mention under a negation ("do not edit files", "without deleting") forbids
+// the action instead of asking for it, so it seeds no ask. Any plain mention
+// elsewhere in the objective still does.
+const NEGATION_BEFORE = /\b(?:not|never|no|don'?t|do\s+not|without|avoid|nor)\s+(?:\w+\s+){0,2}$/i;
+
+// Categories are written in policy words ("destructive-file-action",
+// "external-send"), objectives in plain ones ("delete the old logs", "email
+// the client"). Each head word below also matches the plain words that mean
+// it. Kept short on purpose: every word added is a chance to hold a mission
+// that did nothing risky, so only words that name the action itself go here
+// (not "message", "post", "clean", "update").
+const CATEGORY_SYNONYMS = Object.freeze({
+  destructive: ['delete', 'remove', 'erase', 'wipe', 'purge', 'destroy'],
+  external: ['send', 'email', 'publish'],
+  billing: ['charge', 'refund', 'spend', 'invoice'],
+  spend: ['charge', 'refund', 'purchase'],
+  send: ['email'],
+  delete: ['erase', 'purge'],
+});
+
+// A category's own head word matches as a prefix (existing behavior); a
+// synonym matches only as that word with an ordinary ending, so "send" does
+// not fire on "sender" or "remove" on "removable".
+const SYNONYM_ENDINGS = '(?:e|es|s|ed|ing|al|ion|ions)?';
+
+// True when the pattern matches somewhere that is not under a negation.
+function mentionedWithoutNegation(text, pattern) {
+  const re = new RegExp(pattern.source, 'gi');
+  let match;
+  while ((match = re.exec(text))) {
+    if (!NEGATION_BEFORE.test(text.slice(0, match.index))) return true;
+    if (match[0] === '') re.lastIndex += 1;
+  }
+  return false;
+}
+
+function objectiveNamesCategory(objective, category) {
+  const text = String(objective || '');
+  const head = String(category || '').toLowerCase().split(/[^a-z0-9]+/).filter(Boolean)[0] || '';
+  const stem = categoryStem(category).replace(/[^a-z0-9]/g, '');
+  if (stem && mentionedWithoutNegation(text, new RegExp(`\\b${stem}`))) return true;
+  // "wipe" reads as wip(ing), "delete" as delet(ion): drop the trailing e.
+  const words = (CATEGORY_SYNONYMS[head] || []).map((w) => w.replace(/e$/, '')).filter(Boolean);
+  if (!words.length) return false;
+  return mentionedWithoutNegation(text, new RegExp(`\\b(?:${words.join('|')})${SYNONYM_ENDINGS}\\b`));
+}
+
+// One open human ask per mission covering every implicated category, so a
+// single yes answers it. Tagged so a "no" can be told apart from a plain
+// answered ask.
+const APPROVAL_ASK_SOURCE = 'member_approval_required';
+
+function memberApprovalAsks(owner, root = process.cwd(), objective = '') {
+  const categories = memberApprovalRequired(owner, root)
+    .filter((category) => objectiveNamesCategory(objective, category));
+  if (!categories.length) return [];
+  return [{
+    text: `Approve ${owner} acting on: ${categories.join(', ')} (MEMBER.md approval-required, named in the objective)`,
+    answered_at: null,
+    source: APPROVAL_ASK_SOURCE,
+    categories,
+  }];
+}
+
+// Asks that stop an explicit `mission run`: every open ask, plus a seeded
+// approval ask that was answered "no" (a denial must not read as clearance).
+function runBlockingAsks(asks) {
+  const list = Array.isArray(asks) ? asks : [];
+  return list
+    .map((ask) => (typeof ask === 'string' ? { text: ask, answered_at: null } : ask))
+    .filter((ask) => ask && String(ask.text || '').trim())
+    .filter((ask) => !ask.answered_at || (ask.source === APPROVAL_ASK_SOURCE && ask.answer !== 'yes'));
+}
+
+module.exports = {
+  memberApprovalAsks,
+  objectiveNamesCategory,
+  parseApprovalRequired,
+  runBlockingAsks,
+};

package/lib/mission-task-gate.js

@@ -0,0 +1,170 @@
+'use strict';
+
+// Done means an accepted task plus a receipt. A mission that is linked to
+// task(s) may not complete just because its verifier passed: every linked task
+// must be done + approval_status accepted, with proof on file. Missions with no
+// linked task are not touched by this gate.
+//
+// Archived tasks: archiving a task wipes its approval (approval_status becomes
+// 'archived'), so an archived task is never counted as accepted. The narrowest
+// safe rule: an archived task does not block, so an abandoned side task cannot
+// jam a mission whose real work was accepted, but a mission whose linked tasks
+// are ALL archived has nothing accepted and is refused. Accepting at least one
+// live linked task (or --force) is what lets it complete. One exception: a
+// task that was done and accepted before the clear-done sweep archived it
+// (archived_from 'done' plus an accepting review event) still counts as accepted.
+
+function linkedTaskRefs(mission) {
+  const refs = [
+    ...(Array.isArray(mission?.task_ids) ? mission.task_ids : []),
+    mission?.xp_task?.task_id,
+    mission?.current_task_id,
+    mission?.task_id,
+  ];
+  return Array.from(new Set(refs.map((ref) => String(ref || '').trim()).filter(Boolean)));
+}
+
+function normalizeRef(taskDb, value) {
+  return taskDb.normalizeTaskRef
+    ? taskDb.normalizeTaskRef(value)
+    : String(value || '').replace(/[^a-zA-Z0-9]/g, '').toUpperCase();
+}
+
+function resolveLinkedTask(taskDb, db, ref, root, cache) {
+  const exact = taskDb.getTask(db, ref);
+  if (exact) return exact;
+  if (!cache.rows) {
+    const workspaceRoot = taskDb.workspaceRoot(root);
+    cache.rows = taskDb.withTaskDisplayRefs(taskDb.listTasks(db, { workspaceRoot }));
+  }
+  const wanted = normalizeRef(taskDb, ref);
+  if (!wanted) return null;
+  const hit = cache.rows.find((row) => (
+    normalizeRef(taskDb, row.display_id) === wanted
+    || normalizeRef(taskDb, row.legacy_ref) === wanted
+  ));
+  return hit ? taskDb.getTask(db, hit.id) : null;
+}
+
+function taskReceipt(taskDb, db, task) {
+  const meta = task.metadata || {};
+  const stored = String(meta.latest_agent_proof || '').trim();
+  if (stored) return stored;
+  const events = taskDb.listTaskEvents(db, { taskId: task.id, order: 'desc', limit: 50 });
+  for (const event of events) {
+    const proof = String(event?.payload?.proof || '').trim();
+    if (proof) return proof;
+  }
+  return '';
+}
+
+// The short id the user types and `atris task` prints (T6V-2), not the long
+// internal id. Falls back to the long id if the board cannot be read.
+function shortTaskRef(taskDb, db, task, root) {
+  try {
+    // `atris task accept` looks a short id up in the current workspace, so a
+    // task that lives in another project keeps its full id, which works anywhere.
+    if (task.workspace_root && taskDb.workspaceRoot(root) !== task.workspace_root) return task.id;
+    const rows = taskDb.withTaskDisplayRefs(taskDb.listTasks(db, { workspaceRoot: task.workspace_root || taskDb.workspaceRoot(root) }));
+    const hit = rows.find((row) => row.id === task.id);
+    if (hit && hit.display_id) return hit.display_id;
+  } catch {
+    // fall through to the long id
+  }
+  return task.display_id || task.id;
+}
+
+// The clear-done sweep archives finished tasks, accepted ones included, and
+// archiving overwrites the approval. A task that was done when archived and
+// has an accepting review on record (reward above zero) still counts as
+// accepted; anything else archived does not.
+function wasAcceptedBeforeArchive(taskDb, db, task) {
+  const meta = task.metadata || {};
+  if (meta.archived_from !== 'done') return false;
+  try {
+    return taskDb.listTaskEvents(db, { taskId: task.id, order: 'desc', limit: 200 })
+      .some((event) => (event.event_type === 'reviewed' || event.eventType === 'reviewed') && Number(event?.payload?.reward) > 0);
+  } catch {
+    return false;
+  }
+}
+
+function acceptCommand(ref, hasStoredProof) {
+  return hasStoredProof
+    ? `atris task accept ${ref}`
+    : `atris task accept ${ref} --proof "<receipt: what was checked>"`;
+}
+
+// Returns { ok: true, source, tasks } or { ok: false, source, task_id, reason,
+// accept_command, tasks }. Infrastructure trouble (no task db) and linked ids
+// that no longer resolve are skipped, never blocking: the gate only refuses on
+// a task it can actually see.
+function missionLinkedTaskGate(mission, root = process.cwd(), deps = {}) {
+  const refs = linkedTaskRefs(mission);
+  if (!refs.length) return { ok: true, source: 'no_linked_task', tasks: [] };
+  let taskDb;
+  let db;
+  try {
+    taskDb = deps.taskDb || require('./task-db');
+    db = taskDb.open();
+  } catch {
+    return { ok: true, source: 'task_db_unavailable', tasks: [] };
+  }
+  const cache = {};
+  const checked = [];
+  for (const ref of refs) {
+    let task = null;
+    try {
+      task = resolveLinkedTask(taskDb, db, ref, root, cache);
+    } catch {
+      task = null;
+    }
+    if (!task) continue;
+    const meta = task.metadata || {};
+    const archived = task.status === 'archived' || meta.approval_status === 'archived';
+    const acceptedBeforeArchive = archived && wasAcceptedBeforeArchive(taskDb, db, task);
+    if (archived && !acceptedBeforeArchive) {
+      checked.push({ task_id: task.id, task_ref: shortTaskRef(taskDb, db, task, root), state: 'archived', skipped: true });
+      continue;
+    }
+    const shortRef = shortTaskRef(taskDb, db, task, root);
+    const approval = meta.approval_status || 'none';
+    const receipt = taskReceipt(taskDb, db, task);
+    const hasStoredProof = Boolean(String(meta.latest_agent_proof || '').trim());
+    const accepted = acceptedBeforeArchive || (task.status === 'done' && approval === 'accepted');
+    checked.push({ task_id: task.id, task_ref: shortRef, state: accepted ? 'accepted' : task.status, approval_status: approval, has_receipt: Boolean(receipt) });
+    if (accepted && receipt) continue;
+    const reason = accepted
+      ? `linked task ${shortRef} is accepted but has no receipt on file`
+      : `linked task ${shortRef} is ${task.status} (approval: ${approval}), not accepted`;
+    return {
+      ok: false,
+      source: 'linked_task',
+      task_id: task.id,
+      task_ref: shortRef,
+      reason,
+      // An accepted task cannot be accepted again; only the operator override
+      // (--force) can wave through one that carries no receipt at all.
+      accept_command: accepted ? null : acceptCommand(shortRef, hasStoredProof),
+      tasks: checked,
+    };
+  }
+  // Every linked task we could see was archived: none was ever accepted.
+  if (checked.length && checked.every((entry) => entry.state === 'archived')) {
+    const names = checked.map((entry) => entry.task_ref).join(', ');
+    return {
+      ok: false,
+      source: 'linked_task',
+      task_id: checked[0].task_id,
+      task_ref: checked[0].task_ref,
+      reason: `every linked task (${names}) was archived and none was accepted`,
+      // An archived task cannot be accepted; link a live task and accept it.
+      accept_command: null,
+      archived_only: true,
+      tasks: checked,
+    };
+  }
+  return { ok: true, source: 'linked_tasks_accepted', tasks: checked };
+}
+
+module.exports = { missionLinkedTaskGate, linkedTaskRefs };

package/lib/one-lap-validator.js

@@ -10,6 +10,7 @@ function taskTitle(task) {
 
 function buildOneLapValidatorPrompt(task, options = {}) {
   const verifier = String(options.verifierCommand || '').trim();
+  const baseRef = String(options.baseRef || 'HEAD').trim();
   const executor = String(options.executorEngine || 'executor').trim();
   return [
     'You are the independent validator for a completed one-lap build.',
@@ -22,7 +23,7 @@ function buildOneLapValidatorPrompt(task, options = {}) {
     `Required verifier: ${verifier}`,
     '',
     'Validate in a fresh context:',
-    '1. Read atris/MAP.md when present; inspect git diff origin/master...HEAD, git diff HEAD, and git status --short.',
+    `1. Read atris/MAP.md when present; inspect git diff ${baseRef}...HEAD, git diff HEAD, and git status --short.`,
     '2. Decide whether the committed diff implements the task without unrelated or unsafe changes.',
     '3. Run the required verifier exactly as written and bare. A nonzero exit is a rejection.',
     '4. End with exactly one verdict line as the final nonblank line:',

package/lib/roster-runs.js

@@ -120,6 +120,20 @@ function parseRunUsage({ usage = null, cost_usd = null, stdout = '', stderr = ''
   return found;
 }
 
+// A run that did not land always says why in one plain line when it is shown
+// with --json. Writers that know the cause pass it as `detail`; this is the
+// fallback for a failed, stalled or credit-out run that has none. It is not
+// stored, so the log can still tell a real reason from the filler. A landed
+// run needs no reason.
+function runReason(run) {
+  if (!run || run.outcome === 'landed') return '';
+  const given = clean(run.detail);
+  if (given) return given.slice(0, 240);
+  if (run.outcome === 'stalled') return 'it did not finish in time';
+  if (run.outcome === 'credit out') return 'the engine hit its usage limit';
+  return 'it failed and the tool gave no reason';
+}
+
 // One normalized line. Empty fields stay out so a line only says what we know.
 function normalizeRun(input = {}, { now } = {}) {
   const outcome = OUTCOMES.includes(input.outcome) ? input.outcome : 'failed';
@@ -371,6 +385,19 @@ function renderRunLine(run) {
   return `${clockText(run.at)}  ${who}: ${worker}${facts ? ` (${facts})` : ''}, ${outcomeText(run)}`;
 }
 
+// The run as `--json` shows it: always a `model` key (null when the run rode
+// the tool's own default, which atris could not read, with a note saying so)
+// and, for a run that did not land, a one-line reason.
+function runView(run) {
+  const reason = runReason(run);
+  return {
+    ...run,
+    model: run.model || null,
+    ...(run.model ? {} : { model_note: 'the tool picked its own model; it was not recorded' }),
+    ...(reason ? { reason } : {}),
+  };
+}
+
 // Newest first, at most `limit`, optionally one job only.
 function recentRuns(runs, { job = '', limit = 20 } = {}) {
   const wantJob = job ? jobName(job) : '';
@@ -397,4 +424,5 @@ module.exports = {
   summarizeRuns,
   renderRunLine,
   recentRuns,
+  runView,
 };

package/lib/runner-command.js

@@ -9,13 +9,28 @@
 // first in precedence. Precedence: explicit model -> ATRIS_RUNNER_MODEL env ->
 // ATRIS_RUNNER_PROFILE -> legacy ATRIS_CLAUDE_MODEL env -> pinned default.
 const DEFAULT_CLAUDE_RUNNER_MODEL = 'claude-opus-5-5';
-const DEFAULT_FABLE_RUNNER_MODEL = 'claude-fable-5';
+const DEFAULT_FABLE_RUNNER_MODEL = 'claude-fable-5-1';
 const DEFAULT_CLAUDE_RUNNER_BIN = 'claude';
 // Effort words a roster line may carry after the model. Each engine lists the
 // ones its CLI takes; an engine with no list takes none.
 const EFFORT_WORDS = Object.freeze(['low', 'medium', 'high', 'xhigh', 'max']);
 const CLAUDE_EFFORTS = EFFORT_WORDS;
 
+const FRIENDLY_CLAUDE_MODEL_ALIASES = Object.freeze({
+  'opus 5.5': 'claude-opus-5-5',
+  'opus-5.5': 'claude-opus-5-5',
+  'opus 5': 'claude-opus-5',
+  'opus-5': 'claude-opus-5',
+  'opus 4.8': 'claude-opus-4-8',
+  'opus-4.8': 'claude-opus-4-8',
+});
+
+function normalizeClaudeModelName(value) {
+  const trimmed = String(value || '').trim();
+  if (!trimmed) return '';
+  return FRIENDLY_CLAUDE_MODEL_ALIASES[trimmed.toLowerCase()] || trimmed;
+}
+
 // Canonical runner profiles. Each entry is the config an operator would pick
 // on purpose. Aliases (spelling variants of the same profile) resolve to the
 // canonical config but are kept OUT of operator-facing lists so config errors
@@ -195,13 +210,13 @@ function runnerProfileValue(key) {
 }
 
 function resolveClaudeRunnerModel(mission) {
-  const explicit = mission && mission.model != null ? String(mission.model).trim() : '';
+  const explicit = mission && mission.model != null ? normalizeClaudeModelName(mission.model) : '';
   if (explicit) return explicit;
-  const env = firstConfiguredEnv(['ATRIS_RUNNER_MODEL']);
+  const env = normalizeClaudeModelName(firstConfiguredEnv(['ATRIS_RUNNER_MODEL']));
   if (env) return env;
-  const profileModel = runnerProfileValue('model');
+  const profileModel = normalizeClaudeModelName(runnerProfileValue('model'));
   if (profileModel) return profileModel;
-  const legacyEnv = firstConfiguredEnv(['ATRIS_CLAUDE_MODEL']);
+  const legacyEnv = normalizeClaudeModelName(firstConfiguredEnv(['ATRIS_CLAUDE_MODEL']));
   if (legacyEnv) return legacyEnv;
   return DEFAULT_CLAUDE_RUNNER_MODEL;
 }
@@ -231,9 +246,13 @@ function ownModelsOnlyEngineForBin(bin) {
 // claude env pin) and rides its own default instead.
 function runnerModelFor(engineId, model) {
   // Required here, not at the top: engine-registry requires this file.
-  const { isClaudeFamilyModel, currentClaudeModel } = require('./engine-registry');
-  const value = currentClaudeModel(String(model || '').trim());
+  const { isClaudeFamilyModel, currentClaudeModel, claudeModelId } = require('./engine-registry');
   const name = String(engineId || '').trim().toLowerCase();
+  // A display name like "opus 5.5" only becomes an id for the claude cli (or
+  // an unnamed engine). Any other engine's model name is handed over as is.
+  const canonical = RUNNER_PROFILE_ALIASES[name] || name;
+  const claudeCli = !canonical || canonical === 'claude' || canonical === 'fable' || canonical === 'haiku';
+  const value = claudeCli ? claudeModelId(String(model || '').trim()) : currentClaudeModel(String(model || '').trim());
   const def = RUNNER_PROFILE_DEFS[RUNNER_PROFILE_ALIASES[name] || name];
   if (!value || !def || !def.ownModelsOnly) return value;
   return isClaudeFamilyModel(value) ? '' : value;
@@ -339,7 +358,12 @@ function buildRunnerCommand({ promptFile, allowedTools, model, effort } = {}) {
   // profile, with or without a template.
   const profile = resolveRunnerProfileName();
   const binEngine = ownModelsOnlyEngineForBin(resolveClaudeRunnerBin());
-  const modelFor = (value) => runnerModelFor(binEngine, runnerModelFor(profile, value));
+  // The second pass only matters for an own-models-only program; skipping it
+  // otherwise keeps a name that is not the claude cli's from being read as one.
+  const modelFor = (value) => {
+    const forProfile = runnerModelFor(profile, value);
+    return binEngine ? runnerModelFor(binEngine, forProfile) : forProfile;
+  };
   if (template) {
     return renderRunnerCommandTemplate(template, {
       promptFile,

package/lib/task-db.js

@@ -454,10 +454,34 @@ function addTask(db, { title, tag, workspaceRoot: ws, sourceKey: sk, metadata, s
   return { id, inserted: true };
 }
 
+// A main checkout's view also covers its linked git worktrees, whose tasks keep
+// the worktree as workspace_root so checks run where the work lives. Only a
+// main checkout with linked worktrees spawns git; any error means exact match.
+const linkedWorktreeCache = new Map();
+function linkedWorktreeRoots(ws) {
+  if (linkedWorktreeCache.has(ws)) return linkedWorktreeCache.get(ws);
+  let roots = [];
+  try {
+    if (fs.existsSync(path.join(ws, '.git', 'worktrees'))) {
+      const out = require('child_process').execFileSync('git', ['worktree', 'list', '--porcelain'],
+        { cwd: ws, encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] });
+      roots = out.split('\n').filter(l => l.startsWith('worktree '))
+        .map(l => { const p = l.slice(9); try { return fs.realpathSync(p); } catch { return p; } })
+        .filter(p => p !== ws);
+    }
+  } catch { roots = []; }
+  linkedWorktreeCache.set(ws, roots);
+  return roots;
+}
+
 function listTasks(db, { workspaceRoot: ws, status, claimedBy, limit }) {
   const where = [];
   const args = [];
-  if (ws) { where.push('workspace_root = ?'); args.push(ws); }
+  if (ws) {
+    const roots = [ws, ...linkedWorktreeRoots(ws)];
+    where.push(`workspace_root IN (${roots.map(() => '?').join(', ')})`);
+    args.push(...roots);
+  }
   if (status) { where.push('status = ?'); args.push(status); }
   if (claimedBy) { where.push('claimed_by = ?'); args.push(claimedBy); }
   const sql = `

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.68.2",
+  "version": "3.68.3",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {
@@ -53,6 +53,10 @@
     "atris/team/customer-lead/SOUL.md",
     "atris/team/customer-lead/START_HERE.md",
     "atris/team/customer-lead/skills/customer-commitments/SKILL.md",
+    "atris/team/navigator/skills/loophole-proof-planner/SKILL.md",
+    "atris/team/executor/skills/isolated-slice-builder/SKILL.md",
+    "atris/team/validator/skills/cross-model-referee/SKILL.md",
+    "atris/team/researcher/skills/grounded-evidence-brief/SKILL.md",
     "atris/team/opus-overnight/MEMBER.md",
     "atris/team/opus-overnight/MISSION.md",
     "atris/team/opus-overnight/START_HERE.md",

package/scripts/det/ytnotes

@@ -184,18 +184,41 @@ transcribe_locally() {
   fi
   echo "No captions on this video. Transcribing the audio on this computer (free, about 1 minute per 15 minutes of video)." >&2
   rm -f "yt_${ID}".audio.*
-  # YouTube refuses some media requests at random (HTTP 403) and allows the
-  # next one, so try the download three times before giving up.
-  local attempt downloaded=0
-  for attempt in 1 2 3; do
-    if yt-dlp --no-update --quiet --no-warnings --no-playlist \
-        -f "bestaudio[ext=m4a]/bestaudio/best" -o "yt_${ID}.audio.%(ext)s" "$URL" 2>"yt_${ID}.audio.err"; then
-      downloaded=1; break
-    fi
-    [ "$attempt" = 3 ] || sleep "$((attempt * ${ATRIS_YTNOTES_RETRY_SECONDS:-3}))"
+  # When YouTube flags a connection it answers "Sign in to confirm you're not
+  # a bot" to the default player, but the embedded-player client still gets
+  # audio. Try each client in ATRIS_YTNOTES_AUDIO_CLIENTS in order ("default"
+  # = yt-dlp's own pick). A bot answer moves to the next client at once.
+  # YouTube also refuses some media requests at random (HTTP 403) and allows
+  # the next one, so each client gets three tries for any other error.
+  # Browser cookies are opt-in only: ATRIS_YTNOTES_COOKIES_FROM_BROWSER=safari.
+  local cookie_args=()
+  if [ -n "${ATRIS_YTNOTES_COOKIES_FROM_BROWSER:-}" ]; then
+    cookie_args=(--cookies-from-browser "$ATRIS_YTNOTES_COOKIES_FROM_BROWSER")
+  fi
+  local client attempt downloaded=0 blocked=1
+  for client in ${ATRIS_YTNOTES_AUDIO_CLIENTS:-web_embedded default}; do
+    local client_args=()
+    [ "$client" = default ] || client_args=(--extractor-args "youtube:player_client=$client")
+    for attempt in 1 2 3; do
+      # ${a[@]+...} keeps empty arrays safe under set -u in macOS bash 3.2.
+      if yt-dlp --no-update --quiet --no-warnings --no-playlist \
+          ${client_args[@]+"${client_args[@]}"} ${cookie_args[@]+"${cookie_args[@]}"} \
+          -f "bestaudio[ext=m4a]/bestaudio/best" -o "yt_${ID}.audio.%(ext)s" "$URL" 2>"yt_${ID}.audio.err"; then
+        downloaded=1; break 2
+      fi
+      if grep -qiE "not a bot|sign in to confirm" "yt_${ID}.audio.err" 2>/dev/null; then
+        break
+      fi
+      blocked=0
+      [ "$attempt" = 3 ] || sleep "$((attempt * ${ATRIS_YTNOTES_RETRY_SECONDS:-3}))"
+    done
   done
   if [ "$downloaded" != 1 ]; then
-    LOCAL_FAIL="download: $(grep -m1 ERROR "yt_${ID}.audio.err" 2>/dev/null || echo "yt-dlp failed")"
+    if [ "$blocked" = 1 ] && grep -qiE "not a bot|sign in to confirm" "yt_${ID}.audio.err" 2>/dev/null; then
+      LOCAL_FAIL="blocked"
+    else
+      LOCAL_FAIL="download: $(grep -m1 ERROR "yt_${ID}.audio.err" 2>/dev/null || echo "yt-dlp failed")"
+    fi
     rm -f "yt_${ID}".audio.*
     return 1
   fi
@@ -229,6 +252,7 @@ if [ -z "$VTT" ]; then
     echo "No English captions found for $URL." >&2
     case "$LOCAL_FAIL" in
       no-model) echo "This computer has no local speech model to transcribe it." >&2 ;;
+      blocked) echo "YouTube is blocking audio downloads from this internet connection right now (it asks to sign in). Try again in a few hours or on another network, or opt in to your browser login: ATRIS_YTNOTES_COOKIES_FROM_BROWSER=safari" >&2 ;;
       download:*|transcribe:*) echo "Local transcription failed (${LOCAL_FAIL})." >&2 ;;
     esac
     echo "Paid notes, 5 credits, refunded if it fails: atris youtube process \"$URL\"" >&2
@@ -388,9 +412,20 @@ agy_is_cli() {
   ! head -c 4096 "$bin" 2>/dev/null | grep -q 'VSCODE_IPC_HOOK_CLI'
 }
 
+# An agy that is not signed in opens a Google login and waits up to 60s, which
+# also pops the Antigravity app. `agy models` fails fast with "Please sign in"
+# and opens nothing, so probe with it. Only that message counts as signed out:
+# any other result (including a slow or odd probe) lets the writer run.
+agy_signed_in() {
+  local out
+  out=$(run_with_timeout 10 agy models </dev/null 2>&1) || true
+  ! printf '%s' "$out" | grep -qi 'sign in'
+}
+
 run_gemini() {
   command -v agy >/dev/null 2>&1 || { echo "agy is not installed" >&2; return 127; }
   agy_is_cli || { echo "agy on PATH is the Antigravity editor launcher, which has no -p mode. Install the Antigravity CLI for Gemini notes." >&2; return 127; }
+  agy_signed_in || { echo "agy is installed but not signed in. Run: agy (sign in once) for Gemini notes." >&2; return 127; }
   run_with_timeout 120 agy -p "$PROMPT" --model "${ATRIS_YTNOTES_GEMINI_MODEL:-${1:-gemini-3.8-flash}}" \
     --effort "${2:-low}" --print-timeout 110s </dev/null
 }
@@ -459,6 +494,10 @@ run_auto() {
     IFS='|' read -r cmd model effort label <<< "$entry"
     command -v "$cmd" >/dev/null 2>&1 || continue
     if [ "$cmd" = agy ] && ! agy_is_cli; then continue; fi
+    if [ "$cmd" = agy ] && ! agy_signed_in; then
+      echo "agy is installed but not signed in; skipping Gemini. Run: agy (sign in once)." >&2
+      continue
+    fi
     if [ -n "$tried" ]; then
       echo "$tried did not answer; writing the notes with $label instead." >&2
     fi