atris 3.64.0 → 3.66.0

package/commands/hire.js

@@ -0,0 +1,189 @@
+'use strict';
+
+// atris hire "<name>" --job "<idea>"   one call: member, inbox, allowance, nightly loop
+// atris hires                         the morning check-in: one line per hire, then its 24h / 7d scoreboard
+// Backend: POST /api/business/{id}/hire, GET /api/business/{id}/hires
+
+const { apiRequestJson } = require('../utils/api');
+const { NOT_LOGGED_IN } = require('../lib/developer-api');
+const {
+  parseArgs, businessOrSay, loginToken, errorText, relativeTime, dollars, clip,
+} = require('../lib/business-target');
+
+const HIRE_FLAGS = { switches: ['outreach'], values: ['job', 'budget', 'schedule', 'timezone'] };
+
+function hireHelp(log = console.log) {
+  log(`usage: atris hire "<name>" --job "<idea>" [--budget 50] [--outreach] [--schedule nightly] [--business <slug>] [--json]
+
+hire an agent in one step. it gets a name, a job, its own email inbox,
+a monthly spending allowance, and a work loop that runs overnight.
+
+  --job       the idea it works on, in plain words (required)
+  --budget    most it may ask you to approve per month, in dollars (default 0 = no spending)
+              you still approve every purchase yourself
+  --outreach  mark it as doing outreach (recorded; it uses a normal inbox for now)
+  --schedule  nightly (default, 2 AM your time), hourly, or a cron like "0 3 * * *"
+  --timezone  defaults to this computer's timezone
+  --business  which business; defaults to the business folder you are in
+
+running it again with the same name is safe: you get the same hire back,
+and anything missing (like the inbox) is filled in. --budget changes the allowance.
+
+then each morning: atris hires`);
+}
+
+function hiresHelp(log = console.log) {
+  log(`usage: atris hires [--business <slug>] [--json]
+
+the morning check-in: one line per hire with its email in the last day,
+what it spent this month, and what its last overnight run did. under it,
+its scoreboard for the last 24 hours and 7 days: emails sent, how many got
+a reply from a person, bounces, and spend.`);
+}
+
+function localTimezone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || '';
+  } catch {
+    return '';
+  }
+}
+
+function renderHire(data = {}, now = Date.now()) {
+  const m = data.member || {};
+  const lines = [data.created ? `Hired ${m.name}.` : `${m.name} was already hired. Same hire, nothing duplicated.`];
+  if (m.job) lines.push(`Job: ${clip(m.job, 200)}`);
+  if (data.inbox && data.inbox.address) lines.push(`Inbox: ${data.inbox.address}`);
+  const a = data.allowance || {};
+  lines.push(Number(a.monthly_usd) > 0
+    ? `Allowance: ${dollars(a.monthly_usd)} a month. You still approve every purchase.`
+    : 'Allowance: none. It cannot ask to spend money.');
+  if (a.note) lines.push(`  ${a.note}`);
+  const s = data.schedule || {};
+  let when = s.label ? `Works ${s.label}.` : 'Works on its schedule.';
+  if (s.enabled === false) when += ' Asleep right now.';
+  else if (data.next_run_at) when += ` First run ${relativeTime(data.next_run_at, now)}.`;
+  lines.push(when);
+  if (data.outreach && data.outreach.requested) lines.push(`Outreach: ${data.outreach.note || 'recorded.'}`);
+  lines.push('', 'Check in each morning: atris hires');
+  return lines.join('\n');
+}
+
+function hireLine(h = {}, now = Date.now()) {
+  const parts = [];
+  if (h.status && h.status !== 'active') {
+    const why = { needs_inbox: 'paused, no inbox yet', needs_allowance: 'paused, allowance not set up', setting_up: 'still setting up',
+      pending_schedule: 'set up, nightly work not switched on yet (run the same hire again)' };
+    parts.push(why[h.status] || `paused (${h.status})`);
+  }
+  const mail = h.emails_last_24h;
+  if (mail) parts.push(`sent ${mail.sent}, got ${mail.received} emails today`);
+  else parts.push('no inbox');
+  const a = h.allowance || {};
+  if (Number(a.monthly_usd) > 0) {
+    parts.push(a.spent_this_month_usd == null
+      ? `${dollars(a.monthly_usd)} a month`
+      : `spent ${dollars(a.spent_this_month_usd)} of ${dollars(a.monthly_usd)}`);
+  }
+  if (h.last_run_at) {
+    const result = h.last_result ? `: ${clip(h.last_result, 80)}` : '';
+    parts.push(`last ran ${relativeTime(h.last_run_at, now)}${result}`);
+  } else if (h.schedule && h.schedule.enabled === false) {
+    parts.push('asleep, has not run');
+  } else if (h.next_run_at) {
+    parts.push(`first run ${relativeTime(h.next_run_at, now)}`);
+  } else {
+    parts.push('has not run yet');
+  }
+  return `${h.name}: ${parts.join(' · ')}`;
+}
+
+function windowText(label, w) {
+  if (!w || w.sent == null) return '';
+  const replies = Number(w.replies) || 0;
+  const value = w.reply_rate == null || w.reply_rate === '' ? NaN : Number(w.reply_rate);
+  const rate = Number.isFinite(value) ? ` (${Math.round(value * 100)}%)` : '';
+  const parts = [`sent ${w.sent}`, `${replies} ${replies === 1 ? 'reply' : 'replies'}${rate}`,
+    `${Number(w.bounces) || 0} bounced`];
+  if (w.spend_cents != null) parts.push(`spent ${dollars(Number(w.spend_cents) / 100)}`);
+  return `${label}: ${parts.join(', ')}`;
+}
+
+// The second line under a hire: how its mail is landing. Empty for an older backend.
+function scoreLine(board, now = Date.now()) {
+  if (!board) return '';
+  const parts = [windowText('last 24h', board.last_24h), windowText('last 7 days', board.last_7d)].filter(Boolean);
+  if (!parts.length) return '';
+  if (board.last_action_at) parts.push(`last action ${relativeTime(board.last_action_at, now)}`);
+  if (board.capped) parts.push('counts cover only the newest mail');
+  return `  ${parts.join(' · ')}`;
+}
+
+function renderHires(data = {}, now = Date.now()) {
+  const rows = Array.isArray(data.hires) ? data.hires : [];
+  if (!rows.length) return 'No hires yet. Start one: atris hire "Maya" --job "grow the newsletter"';
+  return rows.map((h) => [hireLine(h, now), scoreLine(h.scoreboard, now)].filter(Boolean).join('\n')).join('\n');
+}
+
+function io(deps) {
+  return { log: deps.log || console.log, err: deps.err || console.error };
+}
+
+async function hireCommand(args = [], deps = {}) {
+  const out = io(deps);
+  const { flags, pos, error } = parseArgs(args, HIRE_FLAGS);
+  if (flags.help || pos[0] === 'help') { hireHelp(out.log); return 0; }
+  if (error) { out.err(`${error}. see: atris hire --help`); return 1; }
+
+  const name = pos.join(' ').trim();
+  const job = typeof flags.job === 'string' ? flags.job.trim() : '';
+  if (!name) { out.err('give the hire a name: atris hire "Maya" --job "<idea>"'); return 1; }
+  if (!job) { out.err('give the hire a job: --job "<the idea to grow>"'); return 1; }
+  const body = { name, job, outreach: flags.outreach === true };
+  if (flags.budget != null) {
+    const budget = Number(flags.budget);
+    if (!Number.isInteger(budget) || budget < 0 || budget > 1000) {
+      out.err('--budget must be whole dollars from 0 to 1000');
+      return 1;
+    }
+    body.monthly_allowance_usd = budget;
+  }
+  if (typeof flags.schedule === 'string') body.schedule = flags.schedule;
+  const tz = typeof flags.timezone === 'string' ? flags.timezone : (deps.timezone || localTimezone());
+  if (tz) body.timezone = tz;
+
+  const business = businessOrSay(flags, deps, out.err);
+  if (!business) return 1;
+  const token = await loginToken(deps);
+  if (!token) { out.err(NOT_LOGGED_IN); return 1; }
+
+  const request = deps.apiRequestJson || apiRequestJson;
+  const result = await request(`/business/${encodeURIComponent(business.id)}/hire`, {
+    method: 'POST', token, body, timeoutMs: 60000, retries: 0,
+  });
+  if (!result || !result.ok) { out.err(`Could not hire ${name}: ${errorText(result)}`); return 1; }
+  if (flags.json) out.log(JSON.stringify(result.data));
+  else out.log(renderHire(result.data, deps.now ? deps.now() : Date.now()));
+  return 0;
+}
+
+async function hiresCommand(args = [], deps = {}) {
+  const out = io(deps);
+  const { flags, pos, error } = parseArgs(args, {});
+  if (flags.help || pos[0] === 'help') { hiresHelp(out.log); return 0; }
+  if (error) { out.err(`${error}. see: atris hires --help`); return 1; }
+  if (pos.length) { out.err(`atris hires takes no other words (got "${pos[0]}"). see: atris hires --help`); return 1; }
+  const business = businessOrSay(flags, deps, out.err);
+  if (!business) return 1;
+  const token = await loginToken(deps);
+  if (!token) { out.err(NOT_LOGGED_IN); return 1; }
+
+  const request = deps.apiRequestJson || apiRequestJson;
+  const result = await request(`/business/${encodeURIComponent(business.id)}/hires`, { method: 'GET', token });
+  if (!result || !result.ok) { out.err(`Could not load hires: ${errorText(result)}`); return 1; }
+  if (flags.json) out.log(JSON.stringify(result.data));
+  else out.log(renderHires(result.data, deps.now ? deps.now() : Date.now()));
+  return 0;
+}
+
+module.exports = { hireCommand, hiresCommand, renderHire, renderHires, hireLine, scoreLine };

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) {