atris 3.65.0 → 3.66.0

package/atris/skills/engines/SKILL.md

@@ -95,7 +95,7 @@ Smoke: `reply with the word OK`, run from `$HOME`, 120s cap, one at a time on a
 | Cursor | `cursor-agent --trust --model composer-2.5 -p "<prompt>"` (run from the target repo) | `composer-2.5` | 2026-09-23 | 37.5 | `--trust` required for non-interactive. |
 | Fable | `atris engine fable --timeout 120 --json "<question>"` | `claude-fable-5` | 2026-09-23 | 21.4 | Canonical read-only FABLE ask with receipt; scale `--timeout` to the work. |
 | Composer | `cursor-agent --trust --model composer-2.5 -p "<prompt>"` | `composer-2.5` via Cursor | 2026-09-23 | 37.5 | Same binary as Cursor. |
-| Haiku | `claude -p "<prompt>" --model claude-haiku-4-5 --output-format json --no-session-persistence` | `claude-haiku-4-5` | 2026-09-23 | 19.0 | Fast validation and bounded read-only checks. |
+| Haiku | `claude -p "<prompt>" --model claude-haiku-5-5 --output-format json --no-session-persistence` | `claude-haiku-5-5` | 2026-10-07 | 9.5 | Fast validation and bounded read-only checks. |
 | Devin (build) | `devin -p --permission-mode dangerous --model swe-2-max --prompt-file <brief>` (run from an isolated worktree) | `swe-2-max` (Free tag in `devin models list`, 2026-09-23) | 2026-09-23 | 14.0 | In `-p` mode the default permission mode rejects shell commands too, so even a read-only audit dies after one step (2026-09-23). Keep the brief outside the worktree. Long runs (5+ min) can print nothing even on success: judge by the worktree diff. `devin cloud` outlives this machine. |
 | Devin (search) | `devin -p --permission-mode dangerous --model swe-1.7-lightning -- "<prompt>"` | `swe-1.7-lightning` (paid, no Free tag on 2026-09-23) | 2026-09-23 | 13.9 | |
 | Grok | `grok --always-approve --model grok-4.7 -p "<prompt>"` (run from the target repo) | `grok-4.7` | 2026-09-23 | 11.7 | Unpinned default is now `grok-4.7-build-fast`; `grok models` lists the menu. Uses grok.com login. `--best-of-n <N>` for tricky bounded builds. |
@@ -119,7 +119,7 @@ Headless dispatch permissions (verified 2026-08-11): `codex exec`, `grok`, and `
 
 | Engine | Flag | Alternates on the live menu |
 |--------|------|-----------------------------|
-| Claude | `--model <id>` | `claude-opus-5-5`, `claude-haiku-4-5` |
+| Claude | `--model <id>` | `claude-opus-5-5`, `claude-haiku-5-5` |
 | Devin | `--model <id>` | `swe-2-max`, `swe-2-high`, `swe-2-medium` (Free); `claude-opus-5-5-high`, `gpt-6-sol` (paid) |
 | Cursor | `--model <id>` | `composer-2.5`, `grok-4.7-xhigh`, `claude-opus-5-thinking-high`; `--list-models` |
 | Grok | `--model <id>` | `grok-4.7`, `grok-4.7-build-fast` (default), `grok-4.6`, `grok-4.5`; `grok models` |

package/bin/atris.js

@@ -632,6 +632,7 @@ function showHelpAll() {
   console.log('  rsi        - Read the Dream-RSI attempt ledger (trees, attempts, policy, dreams)');
   console.log(`  autoland   - Approve the policy once; ${require('../lib/autoland').certifiedWorkLandsPhrase(process.cwd())}, you keep irreversible calls`);
   console.log('  engine     - engine registry, answer validation, dispatch flights, and live progress');
+  console.log('  link       - What two things could become together: one line, why, a first thing to make, who makes it');
   console.log('  ci         - run github actions jobs locally with runs-on: atris');
   console.log('  router     - inspect ax lane outcomes and promote gated reflex overrides');
   console.log('  sign       - Co-author trailer on every commit in an atris workspace (on/off/status)');
@@ -752,6 +753,7 @@ function showHelpAll() {
   console.log('  member list          - Show all team members');
   console.log('  member activate <n>  - Activate a member (link skills, show context)');
   console.log('  member upgrade <n>   - Convert flat file to directory format');
+  console.log('  member result <n>    - Newest run of a member: run record, receipt, artifacts, result number');
   console.log('');
   console.log('Plugin:');
   console.log('  plugin build        - Package skills as .plugin for Cowork');
@@ -1776,9 +1778,28 @@ function showWelcomeVisualization() {
     // Document health is advisory and must never prevent startup.
   }
 
+  // What the background cleanup did lately, in its own plain words: the
+  // newest line the hourly autoland tick or a project job left in the
+  // journal, plus agent branches parked for a person.
+  try {
+    const lately = require('../lib/cleanup-summary').latestCleanupLine(cwd);
+    if (lately) console.log(row('lately', lately));
+  } catch {
+    // Advisory only; never blocks boot.
+  }
+
+  // When the hourly autoland tick is alive it lands, salvages, and clears
+  // finished branches and old agent copies itself, so boot must not hand the
+  // owner that chore ("39 finished pieces to put away"). Only a dead or
+  // missing heartbeat brings the tidy counts and `land --reap` back.
+  let autolandAlive = false;
+  try { autolandAlive = require('../lib/autoland').heartbeatIsLive(cwd); } catch { autolandAlive = false; }
+
   // landSummary is expensive (git board classification) - compute once per boot.
   let landInfo = null;
-  try { landInfo = require('../commands/land').landSummary(cwd); } catch (err) { landInfo = null; }
+  if (!autolandAlive) {
+    try { landInfo = require('../commands/land').landSummary(cwd); } catch (err) { landInfo = null; }
+  }
   let rotInfo = null;
   try {
     const { parseLessons } = require('../lib/memory-view');
@@ -1792,7 +1813,7 @@ function showWelcomeVisualization() {
       worktreeDir = path.join(path.dirname(resolved), '.agent-worktrees', path.basename(resolved));
     }
     let worktrees = 0;
-    if (fs.existsSync(worktreeDir)) {
+    if (!autolandAlive && fs.existsSync(worktreeDir)) {
       worktrees = fs.readdirSync(worktreeDir, { withFileTypes: true })
         .filter((entry) => entry.isDirectory()).length;
     }
@@ -3171,6 +3192,11 @@ if (command === 'guide') {
   Promise.resolve(require('../commands/engine').engineCommand(engineArgs))
     .then((code) => process.exit(typeof code === 'number' ? code : 0))
     .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
+} else if (command === 'link') {
+  // Link: ask the roster's engine what two things could become together.
+  Promise.resolve(require('../commands/link').linkCommand(process.argv.slice(3)))
+    .then((code) => process.exit(typeof code === 'number' ? code : 0))
+    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
 } else if (command === 'playbook') {
   Promise.resolve()
     .then(() => require('../commands/playbook').playbookCommand(process.argv.slice(3)))

package/commands/autoland.js

@@ -555,6 +555,21 @@ function showStatus(root, args) {
     console.log('');
     console.log(`  waiting on a human right now: ${waiting.length}, oldest ${waiting[0].hours}h`);
   }
+  // What the next tick's idle sweep will do, read-only (no check runs here).
+  if (enabled && policy.janitor !== false && policy.idle_sweep !== false) {
+    try {
+      const idle = require('../lib/idle-review-sweep').sweepIdleReviews(root, { tasks, policy, dryRun: true });
+      const days = Number(policy.idle_close_days) > 0 ? Number(policy.idle_close_days) : 7;
+      if (idle.closed.length) {
+        console.log(`  closing on the next tick: ${idle.closed.length} idle over ${days} days that can never land on their own, each with a plain reason.`);
+      }
+      if (idle.human_waiting.length) {
+        console.log(`  staying with you: ${idle.human_waiting.length} in money, deploys, security, or customer work; idle time never closes these.`);
+      }
+    } catch {
+      // Preview only.
+    }
+  }
   console.log('');
   if (!enabled) console.log("  flip it on: atris autoland on   (one decision; everything after is receipts)");
   console.log('');
@@ -798,9 +813,11 @@ async function runTickBody(root, { json, policy, receipt, engineValidationDeps =
     .filter((task) => String(task.review?.approval_status || task.metadata?.approval_status || 'pending') === 'pending')
     .length;
   const accept = runOwnCli(root, cliArgs, acceptSweepTimeoutMs(pendingReviewRows));
+  let acceptResults = [];
   try {
     const parsed = JSON.parse(accept.stdout);
     const results = Array.isArray(parsed.results) ? parsed.results : [];
+    acceptResults = results;
     // A refused sweep (ok:false, a guard tripped, policy race) carries no
     // summary fields. Name the reason instead of leaving nulls that read as
     // "no work": a blind heartbeat must say WHY it is blind.
@@ -963,6 +980,51 @@ async function runTickBody(root, { json, policy, receipt, engineValidationDeps =
     recordLandingSweepState(state, null, { error: receipt.reap_error });
   }
 
+  // 3c2. idle work resolves itself, every tick. Finished work that sat still
+  // past the grace period (policy.idle_close_days, default 7) and can never
+  // land on its own is closed with a plain reason; done and long-idle rows
+  // leave the list. This used to run only when someone opened a session, so
+  // nights and trips piled up work nobody would ever land. Protected lanes
+  // (money, deploys, security, customer, outward) are never closed by idle
+  // time. Off switch: policy.idle_sweep === false or policy.janitor === false.
+  if (policy.janitor !== false && policy.idle_sweep !== false) {
+    try {
+      const liveReasons = new Map(acceptResults
+        .filter((r) => r && r.ref && r.reason && r.action !== 'accepted')
+        .map((r) => [r.ref, r.reason]));
+      const kept = require('../lib/task-list-keeper').keepWorkspaceTaskList(root, { actor: 'autoland', includeDone: false });
+      const idle = require('../lib/idle-review-sweep').sweepIdleReviews(root, {
+        tasks: readProjection(root),
+        policy,
+        liveReasons,
+      });
+      const putAway = (kept.put_away || []).length + (kept.reaped || []).length;
+      if (putAway + idle.closed.length > 0) require('./task').refreshKeptTaskList(root);
+      receipt.idle_sweep = {
+        closed: idle.closed.map((c) => ({ ref: c.ref, reason: c.reason })),
+        put_away: putAway,
+        human_waiting: idle.human_waiting.length,
+      };
+    } catch (err) {
+      receipt.idle_sweep_error = String((err && err.message) || err).slice(0, 200);
+    }
+  }
+  try {
+    const { appendOvernightNote, tickSummaryLine } = require('../lib/cleanup-summary');
+    const line = tickSummaryLine({
+      landed: (receipt.landed || []).length,
+      closed: receipt.idle_sweep ? receipt.idle_sweep.closed.length : 0,
+      putAway: receipt.idle_sweep ? receipt.idle_sweep.put_away : 0,
+      needYou: receipt.idle_sweep ? receipt.idle_sweep.human_waiting : protectedWaiting.length,
+    });
+    if (line) {
+      appendOvernightNote(root, line);
+      receipt.summary_line = line;
+    }
+  } catch {
+    // The journal line is a courtesy; it never fails the tick.
+  }
+
   // 3d. wish sweep: queued wishes are allowed to wake a mission without a
   // foreground `atris wish` session, but they must never endanger landing.
   try {

package/commands/brain.js

@@ -1140,6 +1140,10 @@ function taskEpisodeScorecard(root, episode, workspace, ts = new Date().toISOStr
     task_title: episode.state && episode.state.title || null,
     task_tag: episode.state && episode.state.tag || null,
     actor: episode.action && episode.action.actor || null,
+    // Who built the work. `actor` is the reviewer; trust is earned by the builder.
+    builder: episode.state && episode.state.metadata && episode.state.metadata.built_by
+      || episode.state && episode.state.claimed_by
+      || null,
     reward: Number.isFinite(reward) ? reward : 0,
     reward_source: episode.reward && episode.reward.source || 'task_review',
     lesson: episode.lesson || '',

package/commands/engine.js

@@ -57,6 +57,8 @@ const {
   rosterJobNameError,
   rosterJobRole,
   readRosterState,
+  retiredModelsNamed,
+  RETIRED_CLAUDE_MODELS,
   customRosterJobKeys,
   setRosterPick,
   confirmRoster,
@@ -1161,6 +1163,7 @@ function rosterReport(root = process.cwd(), now = new Date()) {
     jobs,
     expiring,
     renew_command: expiring.length ? RENEW_COMMAND : null,
+    upgraded: upgradedModels(state),
     team: team.rows,
     warnings: [...state.session.warnings, ...state.project.warnings, ...state.machine.warnings, ...team.warnings],
     files: {
@@ -1172,6 +1175,25 @@ function rosterReport(root = process.cwd(), now = new Date()) {
   };
 }
 
+// Retired models a roster file still names. Every read runs them as their
+// replacement, so this is only a heads-up; nobody has to edit the file.
+function upgradedModels(state) {
+  const found = [];
+  for (const layer of [state.session, state.project, state.machine]) {
+    if (!layer || layer.format === 'none' || !layer.path) continue;
+    let text = '';
+    try { text = fs.readFileSync(layer.path, 'utf8'); } catch { continue; }
+    for (const from of retiredModelsNamed(text)) {
+      if (!found.some((item) => item.from === from)) found.push({ from, to: RETIRED_CLAUDE_MODELS[from] });
+    }
+  }
+  return found;
+}
+
+function renderUpgradedLine(upgraded) {
+  return (upgraded || []).map((item) => `note: ${modelLabel(item.from)} is retired, so your roster runs ${modelLabel(item.to)} in its place. no edit needed.`).join('\n');
+}
+
 // Every worker, in any job, whose end date is today or within the next
 // seven days. Workers already past their date show on their own lines. A
 // job set for this shell only is skipped: roster confirm does not renew it.
@@ -1367,7 +1389,7 @@ function renderRosterWarnings(warnings) {
 
 function renderRosterReport(report, { width } = {}) {
   const stale = (report.stale || []).map((item) => item.text);
-  const jobs = [renderJobRoster(report.jobs, { width }), renderExpiringLine(report.expiring), ...stale].filter(Boolean).join('\n');
+  const jobs = [renderJobRoster(report.jobs, { width }), renderExpiringLine(report.expiring), ...stale, renderUpgradedLine(report.upgraded)].filter(Boolean).join('\n');
   return [jobs, renderTeamRoster(report.team, { width }), renderRosterWarnings(report.warnings)]
     .filter(Boolean)
     .join('\n\n');

package/commands/link.js

@@ -0,0 +1,367 @@
+'use strict';
+
+// atris link "<thing a>" "<thing b>" [--context "..."] [--team] [--json]
+//
+// Asks what two things could become together. The answer is one short line
+// naming the connection, a plain why, a bounded first thing to make, and the
+// team member who should make it. The question goes to the roster's engine
+// for the job (a `link` job when the roster has one, else the `build` lead),
+// through the same read-only runner `atris engine ask` uses. Nothing is
+// written except the run record line every ask leaves.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const {
+  MAX_ASK_PROMPT_BYTES,
+  buildReadOnlyEngineInvocation,
+  runAskProcess,
+  runEngineAskJobs,
+} = require('../lib/engine-ask');
+const { isMemberParked } = require('../lib/member-park');
+
+const LINK_TIMEOUT_MS = 180 * 1000;
+const TEAM_FRESH_DAYS = 5;
+const TEAM_NOTE_CHARS = 280;
+const MAX_LINE_WORDS = 12;
+const MEMBER_NAME_RE = /^[a-zA-Z0-9._-]+$/;
+
+const SYSTEM_PROMPT = [
+  'You look at two things a person cares about and say what they could become together.',
+  '',
+  'Rules:',
+  '- Use only facts stated in the two things, the context, and the team notes below. Do not read files, search, or run anything. Do not invent numbers, names, customers, or results.',
+  '- Plain words, the way a person talks. No em dashes. No hype or sales words; say the specific thing.',
+  `- line: one sentence of at most ${MAX_LINE_WORDS} words naming the connection.`,
+  '- why: two or three short sentences. Each one rests on something in the inputs.',
+  '- experiment.label: a small first thing to make, in a few words.',
+  '- experiment.scope: one sentence saying what it will do and what it will not do.',
+  '- by: one slug from the team list, the member best placed to make it, or null when none fits.',
+  '- hunch: true when the connection is a guess rather than grounded in both things; false when both things support it.',
+  '- If nothing specific stands out, answer {"line": null, "reason": "<one plain sentence>"} instead.',
+  '',
+  'Answer with exactly one JSON object and nothing else:',
+  '{"line": "...", "why": "...", "experiment": {"label": "...", "scope": "..."}, "by": "slug-or-null", "hunch": false}',
+].join('\n');
+
+function usage() {
+  return [
+    'usage:',
+    '  atris link "<thing a>" "<thing b>" [--context "<text>"] [--team] [--json]',
+    '',
+    'asks the roster\'s engine what these two things could become together.',
+    '',
+    'options:',
+    '  --context <text>  extra facts the answer may use',
+    `  --team            read each member's now.md (fresh within ${TEAM_FRESH_DAYS} days, not parked) to pick who makes it`,
+    '  --json            print the answer as json',
+  ].join('\n');
+}
+
+function parseLinkArgs(args = []) {
+  const things = [];
+  let context = '';
+  let team = false;
+  let json = false;
+  let help = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = String(args[index]);
+    if (arg === '--help' || arg === '-h') { help = true; continue; }
+    if (arg === '--json') { json = true; continue; }
+    if (arg === '--team') { team = true; continue; }
+    if (arg === '--context') {
+      if (index + 1 >= args.length) throw new Error('--context needs text');
+      context = String(args[index + 1]);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith('--context=')) { context = arg.slice('--context='.length); continue; }
+    if (arg.startsWith('--')) throw new Error(`unknown option ${arg}`);
+    things.push(arg.trim());
+  }
+  if (help) return { help: true, json };
+  if (things.length !== 2 || !things[0] || !things[1]) throw new Error(usage());
+  return { help: false, things, context: context.trim(), team, json };
+}
+
+// The roster's worker for this question: a `link` job when the owner made
+// one, else whoever leads `build`.
+function pickLinkWorker(report) {
+  const jobs = Array.isArray(report && report.jobs) ? report.jobs : [];
+  const row = jobs.find((entry) => entry && entry.job === 'link' && entry.engine)
+    || jobs.find((entry) => entry && entry.job === 'build' && entry.engine);
+  if (!row) return null;
+  return {
+    job: row.job,
+    engine: String(row.engine),
+    model: row.model ? String(row.model) : '',
+    effort: row.effort ? String(row.effort) : '',
+  };
+}
+
+function rosterMemberNames(report, root) {
+  const rows = Array.isArray(report && report.team) ? report.team : [];
+  const names = [];
+  for (const row of rows) {
+    const name = String((row && row.member) || '').trim();
+    if (!name || !MEMBER_NAME_RE.test(name) || names.includes(name)) continue;
+    if (isMemberParked(root, name)) continue;
+    names.push(name);
+  }
+  return names;
+}
+
+function oneLine(text) {
+  return String(text || '').replace(/\s+/g, ' ').trim();
+}
+
+// A member's now.md, trimmed to the first lines that say something: no
+// heading marks, no "Updated:" stamp. Skipped when older than five days.
+function teamNote(root, name, now = Date.now()) {
+  const file = path.join(root, 'atris', 'team', name, 'now.md');
+  let stat;
+  let text;
+  try {
+    stat = fs.statSync(file);
+    text = fs.readFileSync(file, 'utf8');
+  } catch {
+    return null;
+  }
+  if (now - stat.mtimeMs > TEAM_FRESH_DAYS * 86400000) return null;
+  const lines = text.split(/\r?\n/)
+    .map((line) => line.replace(/^#+\s*/, '').trim())
+    .filter((line) => line && line.toLowerCase() !== 'now' && !/^updated:/i.test(line));
+  const note = oneLine(lines.join(' '));
+  if (!note) return null;
+  return note.length > TEAM_NOTE_CHARS ? `${note.slice(0, TEAM_NOTE_CHARS - 3)}...` : note;
+}
+
+function buildLinkPrompt({ things, context, members, notes }) {
+  const parts = [
+    SYSTEM_PROMPT,
+    '',
+    `Thing A: ${oneLine(things[0])}`,
+    `Thing B: ${oneLine(things[1])}`,
+  ];
+  if (context) parts.push(`Context: ${oneLine(context)}`);
+  parts.push('');
+  if (notes && notes.length) {
+    parts.push('Team (slug: what they are on now):');
+    for (const entry of notes) parts.push(`- ${entry.name}: ${entry.note}`);
+  } else {
+    parts.push(`Team slugs: ${members.length ? members.join(', ') : '(none)'}`);
+  }
+  return parts.join('\n');
+}
+
+// Notes go in until the prompt would pass the ask limit; whoever does not
+// fit is still a valid slug, named on the last line.
+function fitTeamNotes(base, notes, members, maxBytes = MAX_ASK_PROMPT_BYTES - 1024) {
+  const kept = [];
+  for (const entry of notes) {
+    const next = buildLinkPrompt({ ...base, members, notes: [...kept, entry] });
+    if (Buffer.byteLength(next) > maxBytes) break;
+    kept.push(entry);
+  }
+  const rest = members.filter((name) => !kept.some((entry) => entry.name === name));
+  let prompt = buildLinkPrompt({ ...base, members, notes: kept });
+  if (kept.length && rest.length) prompt += `\nOther team slugs: ${rest.join(', ')}`;
+  return prompt;
+}
+
+// The same read-only invocation `engine ask` builds, run from the temp
+// folder so the workspace's own notes and memory do not leak into an answer
+// that may use only its inputs. Claude-family engines also lose their read
+// tools for the same reason.
+function linkInvocation(job, timeoutMs) {
+  const invocation = buildReadOnlyEngineInvocation(job.engine, job.prompt, job.model, { timeoutMs, effort: job.effort || '' });
+  const args = [...invocation.args];
+  const tools = args.indexOf('--tools');
+  if (tools >= 0 && tools + 1 < args.length) args[tools + 1] = '';
+  return { ...invocation, args, cwd: os.tmpdir() };
+}
+
+function executeLinkJob(job, { timeoutMs, signal } = {}) {
+  const invocation = linkInvocation(job, timeoutMs);
+  return runAskProcess(invocation, { cwd: invocation.cwd, timeoutMs, signal });
+}
+
+// The engine's text to one object: fences stripped, first "{" to last "}".
+function extractJsonObject(text) {
+  const raw = String(text || '').replace(/```(?:json)?/gi, '').trim();
+  const start = raw.indexOf('{');
+  const end = raw.lastIndexOf('}');
+  if (start < 0 || end <= start) return null;
+  try {
+    const parsed = JSON.parse(raw.slice(start, end + 1));
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+// Em and en dashes become commas, so a rule the model missed never reaches
+// the board.
+function plain(text) {
+  return oneLine(String(text == null ? '' : text)
+    .replace(/\s*[\u2014\u2013]\s*/g, ', ')
+    .replace(/,\s*,/g, ','));
+}
+
+function wordCount(text) {
+  return plain(text).split(' ').filter(Boolean).length;
+}
+
+// Shape the answer into the contract. Returns { ok, value } or
+// { ok: false, error }.
+function normalizeLinkAnswer(parsed, members) {
+  if (!parsed) return { ok: false, error: 'the engine did not answer with a json object' };
+  if (parsed.line === null || parsed.line === undefined || !plain(parsed.line)) {
+    const reason = plain(parsed.reason) || 'nothing specific stood out between these two';
+    return { ok: true, value: { line: null, reason } };
+  }
+  const line = plain(parsed.line);
+  if (wordCount(line) > MAX_LINE_WORDS) {
+    return { ok: false, error: `the line has ${wordCount(line)} words, more than ${MAX_LINE_WORDS}` };
+  }
+  const experiment = parsed.experiment && typeof parsed.experiment === 'object' ? parsed.experiment : {};
+  const label = plain(experiment.label);
+  const scope = plain(experiment.scope);
+  const why = plain(parsed.why);
+  if (!why || !label || !scope) return { ok: false, error: 'the answer is missing why, experiment.label, or experiment.scope' };
+  const by = String(parsed.by == null ? '' : parsed.by).trim();
+  return {
+    ok: true,
+    value: {
+      line,
+      why,
+      experiment: { label, scope },
+      by: by && members.includes(by) ? by : null,
+      hunch: parsed.hunch === true || String(parsed.hunch).toLowerCase() === 'true',
+    },
+  };
+}
+
+function compactFailure(answer) {
+  if (!answer) return 'no answer';
+  if (answer.reason === 'timeout') return `timed out after ${Math.round((answer.duration_ms || 0) / 1000)}s`;
+  const detail = String(answer.stderr || '').trim().split(/\r?\n/).find(Boolean);
+  return detail || String(answer.reason || 'failed').replace(/_/g, ' ');
+}
+
+// One run-record line, job "ask", task "link", so `atris engine roster
+// --runs` shows how long links take. Best effort.
+function recordLinkRun(root, worker, answer, startedAt) {
+  try {
+    const { appendRosterRun, parseRunUsage } = require('../lib/roster-runs');
+    let outcome = 'landed';
+    if (answer && (answer.timed_out || answer.reason === 'timeout')) outcome = 'stalled';
+    else if (!answer || !answer.ok) outcome = 'failed';
+    appendRosterRun(root, {
+      at: startedAt,
+      job: 'ask',
+      engine: worker.engine,
+      model: worker.model,
+      ...(worker.effort ? { effort: worker.effort } : {}),
+      max_seconds: Math.round(LINK_TIMEOUT_MS / 1000),
+      seconds: Math.max(0, (Number(answer && answer.duration_ms) || 0) / 1000),
+      outcome,
+      ...(outcome === 'landed' ? {} : { detail: compactFailure(answer) }),
+      task: 'link',
+      source: 'link',
+      ...parseRunUsage({ stdout: answer && answer.stdout, stderr: answer && answer.stderr }),
+    });
+  } catch { /* best effort */ }
+}
+
+function printHuman(value, ran) {
+  if (value.line === null) {
+    console.log(`\nnothing specific: ${value.reason}\n`);
+    return;
+  }
+  console.log(`\n${value.line}${value.hunch ? '  (hunch)' : ''}`);
+  console.log(`\n  ${value.why}`);
+  console.log(`\n  make: ${value.experiment.label}`);
+  console.log(`        ${value.experiment.scope}`);
+  console.log(`  by:   ${value.by || 'nobody on the team fits yet'}`);
+  console.log(`\n  ${ran.engine}${ran.model ? ` (${ran.model})` : ''}, ${ran.seconds}s\n`);
+}
+
+async function linkCommand(args = [], deps = {}) {
+  const root = deps.root || process.cwd();
+  let parsed;
+  try {
+    parsed = parseLinkArgs(args);
+  } catch (error) {
+    console.error(`link: ${error.message}`);
+    return 2;
+  }
+  if (parsed.help) {
+    console.log(usage());
+    return 0;
+  }
+
+  const fail = (error, extra = {}) => {
+    if (parsed.json) console.log(JSON.stringify({ ok: false, error, ...extra }, null, 2));
+    else console.error(`link: ${error}`);
+    return 1;
+  };
+
+  let report;
+  try {
+    report = deps.rosterReport ? deps.rosterReport(root) : require('./engine').rosterReport(root);
+  } catch (error) {
+    return fail(`could not read the roster: ${error.message || error}`);
+  }
+  const worker = pickLinkWorker(report);
+  if (!worker) return fail('the roster has no build engine; run: atris engine roster');
+
+  const members = rosterMemberNames(report, root);
+  const now = deps.now ? deps.now() : Date.now();
+  const notes = parsed.team
+    ? members.map((name) => ({ name, note: teamNote(root, name, now) })).filter((entry) => entry.note)
+    : [];
+  const base = { things: parsed.things, context: parsed.context };
+  const prompt = notes.length
+    ? fitTeamNotes(base, notes, members)
+    : buildLinkPrompt({ ...base, members, notes: [] });
+
+  const startedAt = new Date().toISOString();
+  const job = { engine: worker.engine, model: worker.model, ...(worker.effort ? { effort: worker.effort } : {}), prompt, label: 'link' };
+  const [answer] = await runEngineAskJobs([job], {
+    root,
+    concurrency: 1,
+    timeoutMs: deps.timeoutMs || LINK_TIMEOUT_MS,
+    executeAskJob: deps.executeAskJob || executeLinkJob,
+  });
+  if (!deps.executeAskJob) recordLinkRun(root, worker, answer, startedAt);
+
+  const ran = {
+    job: worker.job,
+    engine: worker.engine,
+    model: worker.model || null,
+    seconds: Math.round((Number(answer && answer.duration_ms) || 0) / 100) / 10,
+    team_notes: parsed.team ? notes.length : null,
+  };
+  if (!answer || !answer.ok) return fail(`the engine did not answer: ${compactFailure(answer)}`, { ran });
+
+  const result = normalizeLinkAnswer(extractJsonObject(answer.stdout), members);
+  if (!result.ok) return fail(result.error, { ran, raw: String(answer.stdout || '').trim().slice(0, 2000) });
+
+  if (parsed.json) console.log(JSON.stringify({ ...result.value, ran }, null, 2));
+  else printHuman(result.value, ran);
+  return 0;
+}
+
+module.exports = {
+  SYSTEM_PROMPT,
+  linkCommand,
+  parseLinkArgs,
+  pickLinkWorker,
+  teamNote,
+  fitTeamNotes,
+  extractJsonObject,
+  normalizeLinkAnswer,
+  linkInvocation,
+};

package/commands/loops.js

@@ -276,7 +276,10 @@ function structuralProblems({ root, filePath, text, nowMs }) {
 
   const owner = text.match(/\*\*Owner:\*\*\s*`team\/([^`]+)`/)?.[1]?.trim();
   if (!owner) problems.push('no Owner field');
-  else if (!fs.existsSync(path.join(root, 'team', owner))) problems.push(`owner team/${owner} does not exist`);
+  // Members live in atris/team/; older workspaces kept a root team/ folder.
+  else if (![path.join(root, 'atris', 'team', owner), path.join(root, 'team', owner)].some((dir) => fs.existsSync(dir))) {
+    problems.push(`owner team/${owner} does not exist`);
+  }
 
   const wiki = text.match(/\*\*Wiki:\*\*\s*\[[^\]]+\]\(([^)]+)\)/)?.[1]?.trim();
   if (!wiki) {

package/commands/member.js

@@ -9412,7 +9412,7 @@ async function memberCommand(subcommand, ...args) {
   // Subcommands that take a member name as args[0] otherwise treat `--help` as
   // a name and error with "Member '--help' not found". `create`/`new` handle
   // help themselves (with subcommand-specific usage), leave those alone.
-  const HELP_AWARE_SUBCOMMANDS = new Set(['create', 'new', 'run', 'install']);
+  const HELP_AWARE_SUBCOMMANDS = new Set(['create', 'new', 'run', 'install', 'result']);
   if (!HELP_AWARE_SUBCOMMANDS.has(subcommand) && (args[0] === '-h' || args[0] === '--help')) {
     subcommand = undefined;
   }
@@ -9449,6 +9449,11 @@ async function memberCommand(subcommand, ...args) {
       return memberWake(args[0], ...args.slice(1));
     case 'run':
       return memberRun(args[0], ...args.slice(1));
+    case 'result': {
+      const code = require('../lib/member-result').memberResultCommand(args);
+      if (code) process.exitCode = code;
+      return undefined;
+    }
     case 'ping':
       return memberPing(args[0], ...args.slice(1));
     case 'loop':
@@ -9498,6 +9503,7 @@ async function memberCommand(subcommand, ...args) {
       console.log('  goal-from-score <name>    Create/reuse an active goal from Team score evidence');
       console.log('  wake <name>         Read Mission state and decide tick/wait/ask/stop');
       console.log('  run <name> ["..."]  Start a budgeted member mission, or run its active Mission Runtime');
+      console.log('  result <name>       Newest run result: run record, receipt, artifacts, number [--since <iso>] [--json]');
       console.log('  loop <name|--all>   Repeat wake on a bounded cadence with a no-overlap lease');
       console.log('  tick <name>         Propose the next bounded experiment');
       console.log('  review <name> <id>  Accept/discard an experiment with proof');
@@ -9533,6 +9539,7 @@ async function memberCommand(subcommand, ...args) {
       console.log('  atris member wake growth --json');
       console.log('  atris member run growth "improve onboarding proof" --verify "npm test" --minutes 30 --json');
       console.log('  atris member run growth --mission <mission-id> --max-ticks 1 --json');
+      console.log('  atris member result growth --json');
       console.log('  atris member wake growth --execute --confirm-autonomy-policy');
       console.log('  atris member supervisor recommendations --json');
       console.log('  atris member objective-generator proposals --json');

package/commands/orb.js

@@ -42,7 +42,7 @@ function parseEngine(args) {
 }
 
 function engineInvocation(engine, prompt) {
-  if (engine === 'codex') return { command: 'codex', args: ['exec', prompt] };
+  if (engine === 'codex') return { command: 'codex', args: ['exec', '--skip-git-repo-check', prompt] };
   if (engine === 'fast') return { command: 'ax', args: ['--fast', '--print', prompt] };
   return { command: 'claude', args: ['-p', prompt] };
 }