atris 3.59.0 → 3.61.0

package/bin/atris.js

@@ -1850,6 +1850,16 @@ function showWelcomeVisualization() {
     console.log(row('goal', endgameState.horizon || endgameState.slug));
   }
 
+  // Every new chat sees which tool and model does each job, from the same
+  // resolver as atris engine roster. A roster that cannot be read drops the
+  // line; it never stops the boot.
+  try {
+    const teamLine = require('../lib/team-lineup').bootTeamLine(cwd, { width: 80 - 11 });
+    if (teamLine) console.log(row('team', teamLine));
+  } catch {
+    // Silent: the lineup is a hint, not a gate.
+  }
+
   const hasNoTasks = glance.active === 0
     && glance.review === 0
     && glance.reviewCertified === 0;

package/commands/engine.js

@@ -2133,6 +2133,8 @@ module.exports = {
   canonicalEngineName,
   readSavedEngine,
   roster,
+  rosterReport,
+  jobRosterView,
   engineRegistryFile,
   readEngineRegistry,
   resolveEngineForRole,

package/commands/host.js

@@ -5,7 +5,7 @@ const { hostAction } = require('../lib/host');
 function parse(argv) {
   const options = {};
   const positionals = [];
-  const flags = new Set(['id', 'name', 'team', 'manager', 'door', 'now', 'question', 'event-id', 'from', 'text', 'patch', 'expected-revision', 'source', 'evidence', 'reason', 'activity', 'as']);
+  const flags = new Set(['id', 'name', 'team', 'manager', 'door', 'now', 'started', 'question', 'event-id', 'from', 'text', 'reply-to', 'reply-to-ref', 'ref', 'decision', 'patch', 'expected-revision', 'source', 'evidence', 'reason', 'activity', 'as', 'when', 'at']);
   for (let i = 0; i < argv.length; i += 1) {
     const item = argv[i];
     if (item === '--json') { options.json = true; continue; }
@@ -22,6 +22,15 @@ function human(command, result) {
   if (command === 'room') return result.text;
   if (command === 'due') return result.length ? result.map((entry) => `${entry.name} (${entry.id}) is due for a question.`).join('\n') : 'no questions due';
   if (command === 'outbox') return result.length ? result.map((entry) => `${entry.id} ${entry.kind} to ${entry.to}: ${entry.text}`).join('\n') : 'outbox empty';
+  if (command === 'schedule') return result.length ? result.map((entry) => `${entry.attempt_id}: ${entry.names.a} (${entry.a}) and ${entry.names.b} (${entry.b}), ${entry.activity}`).join('\n') : 'no introductions need scheduling';
+  if (command === 'people') {
+    if (!result.length) return 'no active people';
+    return result.map((entry) => {
+      const fields = ['into_lately', 'going_for', 'great_at', 'wants_to_meet', 'worth_celebrating']
+        .map((key) => `  ${key.replaceAll('_', ' ')}: ${entry[key]}`).join('\n');
+      return `${entry.name} (${entry.id})\n  team: ${entry.team || 'none'}\n  manager: ${entry.manager_id || 'none'}\n  status: ${entry.status}\n  can be introduced: ${entry.can_be_introduced ? 'yes' : 'no'}\n${fields}`;
+    }).join('\n');
+  }
   if (command === 'view') return [...result.cards.map((entry) => entry.card), result.own ? `Your private record:\n${JSON.stringify(result.own, null, 2)}` : ''].filter(Boolean).join('\n');
   if (command === 'receive') return result.duplicate ? 'event already recorded' : `${result.kind} recorded for ${result.id}`;
   return `${command} complete: ${JSON.stringify(result)}`;
@@ -32,14 +41,14 @@ function hostCommand(argv = process.argv.slice(3), root = process.cwd()) {
   try {
     const [command, ...rest] = argv;
     if (!command || command === '--help' || command === '-h') {
-      const usage = 'usage: atris host join|leave|pause|resume|forget|due|ask|receive|card|link|propose|outbox|sent|room|view [options]';
+      const usage = 'usage: atris host join|leave|pause|resume|forget|due|ask|receive|card|link|propose|people|outbox|sent|room|view|schedule|scheduled [options]';
       console.log(jsonOutput ? JSON.stringify({ usage }) : usage);
       return;
     }
     const { options, positionals } = parse(rest);
     jsonOutput = options.json;
     const args = { ...options };
-    if (['leave', 'pause', 'resume', 'forget', 'ask', 'card', 'sent'].includes(command)) args.id = positionals[0];
+    if (['leave', 'pause', 'resume', 'forget', 'ask', 'card', 'sent', 'scheduled'].includes(command)) args.id = positionals[0];
     if (['link', 'propose'].includes(command)) { args.a = positionals[0]; args.b = positionals[1]; }
     if (command === 'receive') args.eventId = options.eventId;
     const result = hostAction(root, command, args);

package/commands/team.js

@@ -6,6 +6,7 @@ const path = require('path');
 const { canonicalEngineName } = require('../lib/engine-registry');
 const taskDb = require('../lib/task-db');
 const { buildTeamPresence, DEFAULT_FRESHNESS_WINDOW_MS, renderTeamPresence } = require('../lib/team-presence');
+const { LINEUP_UNREADABLE, memberLineup, readLineupSafe, renderLineup } = require('../lib/team-lineup');
 const { readEngineRegistry } = require('./engine');
 const { listMissions, listWorktreeRollupMissions } = require('./mission');
 const { collectSnapshot, collectStreamEvents, repoRoot } = require('./stream');
@@ -262,6 +263,16 @@ function renderTeamRoster(rosterRows, deps = {}) {
   return lines.join('\n');
 }
 
+// The lineup (who does each job, who is on each job) above today's active
+// and rest lists.
+function renderTeamWithLineup(rosterRows, lineup, deps = {}) {
+  const width = Math.min(deps.termWidth || process.stdout.columns || 80, 100);
+  const today = renderTeamRoster(rosterRows, deps);
+  if (!lineup || !lineup.ok) return `${today}\n\n${LINEUP_UNREADABLE}`;
+  const block = renderLineup(lineup, { width });
+  return block ? `${block}\n\n${today}` : today;
+}
+
 function renderTeamRosterHtml(rosterRows, meta = {}) {
   const activeRows = rosterRows.filter((entry) => entry.active);
   const restRows = rosterRows.filter((entry) => !entry.active);
@@ -485,7 +496,7 @@ function renderTeamPrune(report, days = DEFAULT_PRUNE_DAYS) {
 
 function helpText() {
   return [
-    'atris team - active members and the rest of the roster',
+    'atris team - who does each job, with its tool and model, then active members and the rest',
     'atris team presence - show who is awake and what they are doing',
     'atris team prune - flag members with no recent activity; deletes nothing',
     '',
@@ -535,9 +546,15 @@ function teamCommand(args = [], deps = {}) {
       (deps.write || process.stdout.write.bind(process.stdout))(`${outPath}\n`);
       return 0;
     }
+    // Which job, tool, and model each member runs, from the same resolver
+    // as `atris engine roster`. A roster that cannot be read never hides the
+    // team; it costs one plain line.
+    const lineup = deps.lineup !== undefined
+      ? deps.lineup
+      : readLineupSafe(deps.root || repoRoot(deps.cwd || process.cwd()), deps.lineupNow || new Date());
     const output = json
-      ? JSON.stringify(roster, null, 2)
-      : renderTeamRoster(roster, deps);
+      ? JSON.stringify(roster.map((entry) => ({ ...entry, lineup: memberLineup(lineup, entry.name) })), null, 2)
+      : renderTeamWithLineup(roster, lineup, deps);
     (deps.write || process.stdout.write.bind(process.stdout))(`${output}\n`);
     return 0;
   }

package/lib/host.js

@@ -4,15 +4,17 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 
-const DEFAULT_CONFIG = Object.freeze({ cadence_days: 3, question_expiry_days: 7, pause_after_unanswered: 2, intro_expiry_days: 7, intros_per_person_per_30d: 1 });
-const PERSON_KEYS = ['schema', 'id', 'name', 'team', 'manager_id', 'door', 'status', 'joined_at', 'told_host_sees_at', 'next_question_at', 'pending_question_id', 'pending_question', 'pending_expires_at', 'unanswered_count', 'revision', 'processed_events'];
-const INTRO_KEYS = ['a', 'b', 'attempt_id', 'reason', 'activity', 'version', 'a_said', 'b_said', 'state', 'created_at', 'expires_at', 'closed_reason'];
+const DEFAULT_CONFIG = Object.freeze({ cadence_days: 3, question_expiry_days: 7, pause_after_unanswered: 2, intro_expiry_days: 7, intros_per_person_per_30d: 2, newcomer_intros_first_30d: 3, followup_days: 14, nudge_days: 3, rest_days: 21 });
+const PERSON_KEYS = ['schema', 'id', 'name', 'team', 'manager_id', 'door', 'status', 'joined_at', 'started_at', 'told_host_sees_at', 'next_question_at', 'pending_question_id', 'pending_question', 'pending_expires_at', 'unanswered_count', 'revision', 'processed_events', 'rest_until'];
+const INTRO_KEYS = ['a', 'b', 'attempt_id', 'reason', 'activity', 'version', 'a_said', 'b_said', 'state', 'created_at', 'expires_at', 'closed_reason', 'introduced_at', 'followup_at', 'followup_sent', 'a_met', 'b_met', 'nudge_at', 'nudge_sent', 'schedule_requested', 'scheduled_for', 'scheduled_at'];
+const NEW_INTRO_KEYS = ['introduced_at', 'followup_at', 'followup_sent', 'a_met', 'b_met', 'nudge_at', 'nudge_sent', 'schedule_requested', 'scheduled_for', 'scheduled_at'];
 const CARD_KEYS = ['into_lately', 'going_for', 'great_at', 'wants_to_meet', 'worth_celebrating'];
 const CARD_TITLES = ['Into lately', 'Going for', 'Great at', 'Wants to meet', 'Worth celebrating'];
 
 function fail(message) { throw new Error(message); }
 function required(value, label) { if (typeof value !== 'string' || !value.trim()) fail(`${label} is required`); return value.trim(); }
 function singleLine(value, label) { const text = required(value, label); if (/[\r\n]/.test(text)) fail(`${label} must be one line`); return text; }
+function providerRef(value) { const ref = singleLine(value, 'ref'); if (ref.length > 200) fail('ref must be at most 200 characters'); return ref; }
 function safeId(value) { const id = required(value, 'id'); if (!/^[A-Za-z0-9][A-Za-z0-9:_-]{0,127}$/.test(id)) fail('id must use letters, numbers, colon, underscore, or dash'); return id; }
 function fileId(id) { return encodeURIComponent(safeId(id)); }
 function days(iso, count) { return new Date(Date.parse(iso) + count * 86400000).toISOString(); }
@@ -42,7 +44,7 @@ function rows(file) {
   });
 }
 function putRows(file, entries) { atomic(file, entries.map((entry) => JSON.stringify(entry)).join('\n') + (entries.length ? '\n' : '')); }
-function record(file, keys) {
+function record(file, keys, optional = []) {
   const raw = readText(file);
   if (raw === null) fail(`missing record: ${file}`);
   const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
@@ -53,7 +55,8 @@ function record(file, keys) {
     if (!part || !keys.includes(part[1]) || Object.hasOwn(data, part[1])) fail(`malformed record: ${file}`);
     try { data[part[1]] = JSON.parse(part[2]); } catch { fail(`malformed record: ${file}`); }
   }
-  if (keys.some((key) => !Object.hasOwn(data, key))) fail(`malformed record: ${file}`);
+  if (keys.some((key) => !Object.hasOwn(data, key) && !optional.includes(key))) fail(`malformed record: ${file}`);
+  for (const key of optional) if (!Object.hasOwn(data, key)) data[key] = null;
   return { data, body: match[2] };
 }
 function putRecord(file, keys, data, body = '') {
@@ -81,25 +84,29 @@ function config(root) {
   const file = path.join(privateDir(root), 'config.json');
   if (!fs.existsSync(file)) putJson(file, DEFAULT_CONFIG);
   const value = json(file);
-  if (!value || Object.keys(DEFAULT_CONFIG).some((key) => !Number.isInteger(value[key]) || value[key] < 1)) fail(`malformed config: ${file}`);
-  return value;
+  if (!value || Object.keys(DEFAULT_CONFIG).some((key) => {
+    const setting = Object.hasOwn(value, key) ? value[key] : DEFAULT_CONFIG[key];
+    return !Number.isInteger(setting) || setting < 1;
+  })) fail(`malformed config: ${file}`);
+  return { ...DEFAULT_CONFIG, ...value };
 }
 function people(root) {
   const dir = path.join(privateDir(root), 'people');
   if (!fs.existsSync(dir)) return [];
-  return fs.readdirSync(dir).filter((name) => name.endsWith('.md')).map((name) => record(path.join(dir, name), PERSON_KEYS)).sort((a, b) => a.data.name.localeCompare(b.data.name));
+  return fs.readdirSync(dir).filter((name) => name.endsWith('.md')).map((name) => record(path.join(dir, name), PERSON_KEYS, ['rest_until', 'started_at'])).sort((a, b) => a.data.name.localeCompare(b.data.name));
 }
-function person(root, id) { return record(personPath(root, id), PERSON_KEYS); }
+function person(root, id) { return record(personPath(root, id), PERSON_KEYS, ['rest_until', 'started_at']); }
 function savePerson(root, entry) { entry.data.revision += 1; putRecord(personPath(root, entry.data.id), PERSON_KEYS, entry.data, entry.body); }
 function intros(root) {
   const dir = introDir(root);
   if (!fs.existsSync(dir)) return [];
-  return fs.readdirSync(dir).filter((name) => name.endsWith('.md')).map((name) => ({ file: path.join(dir, name), ...record(path.join(dir, name), INTRO_KEYS) }));
+  return fs.readdirSync(dir).filter((name) => name.endsWith('.md')).map((name) => ({ file: path.join(dir, name), ...record(path.join(dir, name), INTRO_KEYS, NEW_INTRO_KEYS) }));
 }
-function queue(root, to, kind, text, at, attemptId = null) {
+function queue(root, to, kind, text, at, attemptId = null, questionId = null) {
   const recipient = person(root, to).data;
   const message = { id: crypto.randomUUID(), to, door: recipient.door, kind, text, created_at: at, state: 'queued' };
   if (attemptId) message.attempt_id = attemptId;
+  if (questionId) message.question_id = questionId;
   putJson(path.join(outboxDir(root), `${message.id}.json`), message);
   return message;
 }
@@ -132,12 +139,54 @@ function expireQuestions(root, at, settings) {
     dropQueued(root, (message) => message.to === p.id && message.kind === 'question');
     if (p.unanswered_count >= settings.pause_after_unanswered) {
       p.status = 'paused';
+      p.rest_until = days(at, settings.rest_days);
       closeFor(root, p.id, 'pause');
       dropQueued(root, (message) => message.to === p.id);
     }
     savePerson(root, entry);
   }
 }
+function resumeResting(root, at) {
+  for (const entry of people(root)) {
+    const p = entry.data;
+    if (p.status !== 'paused' || !p.rest_until || p.rest_until > at) continue;
+    p.status = 'active'; p.unanswered_count = 0; p.next_question_at = at; p.rest_until = null;
+    savePerson(root, entry);
+  }
+}
+function queueNudges(root, at) {
+  for (const entry of intros(root)) {
+    const intro = entry.data;
+    if (intro.state !== 'introduced' || !intro.nudge_at || intro.nudge_sent || intro.followup_sent || intro.schedule_requested || intro.scheduled_for || intro.nudge_at > at) continue;
+    for (const [id, other] of [[intro.a, intro.b], [intro.b, intro.a]]) {
+      if (person(root, id).data.status !== 'active') continue;
+      queue(root, id, 'nudge', `Want me to find a time for you and ${person(root, other).data.name} to do ${intro.activity}? Reply yes or no (no if you already have one).`, at, intro.attempt_id);
+    }
+    intro.nudge_sent = at;
+    putRecord(entry.file, INTRO_KEYS, intro, entry.body);
+  }
+}
+function queueFollowups(root, at, skipAttempt = null) {
+  for (const entry of intros(root)) {
+    const intro = entry.data;
+    if (intro.state !== 'introduced' || intro.attempt_id === skipAttempt || !intro.followup_at || intro.followup_sent || intro.followup_at > at) continue;
+    for (const [id, other] of [[intro.a, intro.b], [intro.b, intro.a]]) {
+      if (person(root, id).data.status !== 'active') continue;
+      queue(root, id, 'followup', `Did you and ${person(root, other).data.name} end up doing ${intro.activity}? Worth doing again? Reply yes or no.`, at, intro.attempt_id);
+    }
+    intro.followup_sent = at;
+    putRecord(entry.file, INTRO_KEYS, intro, entry.body);
+  }
+}
+function choice(answer) {
+  const first = answer.toLowerCase().match(/[\p{L}\p{N}]+/u)?.[0];
+  if (['yes', 'y', 'yeah', 'yep', 'yup', 'sure', 'absolutely', 'definitely', 'ok', 'okay', 'down', 'totally', 'love'].includes(first)) return 'yes';
+  if (['no', 'n', 'nah', 'nope', 'pass'].includes(first)) return 'no';
+  return null;
+}
+function awaiting(intro, id) {
+  return intro.data.state === 'pending' && [intro.data.a, intro.data.b].includes(id) && intro.data[intro.data.a === id ? 'a_said' : 'b_said'] === null;
+}
 function cardText(name, team, values) {
   return `---\nname: ${JSON.stringify(name)}\nteam: ${JSON.stringify(team)}\n---\n\n# ${name}\n\n${CARD_KEYS.map((key, index) => `## ${CARD_TITLES[index]}\n\n${values[key] || ''}`).join('\n\n')}\n`;
 }
@@ -153,9 +202,17 @@ function cardValues(raw) {
   return values;
 }
 function published(root, id) { const raw = readText(cardPath(root, id)); if (raw === null) fail(`missing published card for ${id}`); return raw; }
+// Activities are read mid-sentence ("find a time to do ..."), so drop end punctuation and a leading capital article.
+function phrase(text) { return text.replace(/[\s.!?]+$/, '').replace(/^(A|An|The|One)\b/, (word) => word.toLowerCase()); }
 function pair(a, b) { return [safeId(a), safeId(b)].sort(); }
+function introLimit(person, at, settings) {
+  const started = Date.parse(person.started_at || person.joined_at), current = Date.parse(at);
+  return started <= current && started >= current - 30 * 86400000 ? settings.newcomer_intros_first_30d : settings.intros_per_person_per_30d;
+}
 
 function hostAction(root, command, arg = {}) {
+  if (command === 'receive' && arg.decision != null && !['yes', 'no'].includes(arg.decision)) fail('decision must be yes or no');
+  if (command === 'receive' && arg.replyTo != null && arg.replyToRef != null) fail('choose --reply-to or --reply-to-ref');
   if (command === 'view') {
     if (arg.as && arg.team) fail('choose --as or --team');
     if (arg.as) {
@@ -170,13 +227,50 @@ function hostAction(root, command, arg = {}) {
     const at = nowIso(arg.now);
     expireIntros(root, at);
     expireQuestions(root, at, settings);
+    resumeResting(root, at);
+    queueNudges(root, at);
+    queueFollowups(root, at, command === 'scheduled' && arg.at != null ? arg.id : null);
     if (command === 'outbox') return messages(root).filter((message) => message.state === 'queued');
+    if (command === 'schedule') return intros(root).filter((entry) => entry.data.state === 'introduced' && entry.data.schedule_requested && !entry.data.scheduled_for).map(({ data }) => ({
+      attempt_id: data.attempt_id, a: data.a, b: data.b,
+      names: { a: person(root, data.a).data.name, b: person(root, data.b).data.name }, activity: data.activity,
+    }));
+    if (command === 'scheduled') {
+      const attempt = required(arg.id, 'attempt id');
+      const entry = intros(root).find((intro) => intro.data.attempt_id === attempt && intro.data.state === 'introduced');
+      if (!entry) fail('unknown introduced attempt');
+      if (entry.data.scheduled_for) fail('introduction already scheduled');
+      const when = singleLine(arg.when, 'when');
+      if (arg.at != null) {
+        if (typeof arg.at !== 'string' || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})$/.test(arg.at)) fail('at must be an ISO time');
+        entry.data.scheduled_at = nowIso(arg.at);
+        if (!entry.data.followup_sent) entry.data.followup_at = new Date(Math.max(Date.parse(at), Date.parse(entry.data.scheduled_at) + 86400000)).toISOString();
+      }
+      entry.data.scheduled_for = when;
+      entry.data.schedule_requested = false;
+      putRecord(entry.file, INTRO_KEYS, entry.data, entry.body);
+      for (const [id, other] of [[entry.data.a, entry.data.b], [entry.data.b, entry.data.a]]) {
+        queue(root, id, 'booked', `Booked: ${entry.data.activity} with ${person(root, other).data.name}, ${when}. Have fun.`, at, attempt);
+      }
+      return { attempt_id: attempt, scheduled_for: when };
+    }
+    if (command === 'people') {
+      const history = intros(root);
+      const recent = history.filter((entry) => Date.parse(entry.data.created_at) > Date.parse(at) - 30 * 86400000);
+      return people(root).filter((entry) => entry.data.status === 'active').map((entry) => ({
+        id: entry.data.id, name: entry.data.name, team: entry.data.team, manager_id: entry.data.manager_id, status: entry.data.status,
+        can_be_introduced: !history.some((intro) => ['pending', 'ready'].includes(intro.data.state) && [intro.data.a, intro.data.b].includes(entry.data.id)) && recent.filter((intro) => [intro.data.a, intro.data.b].includes(entry.data.id)).length < introLimit(entry.data, at, settings),
+        ...cardValues(published(root, entry.data.id)),
+      }));
+    }
     if (command === 'join') {
       const id = safeId(arg.id);
       if (rows(path.join(privateDir(root), 'forgotten.jsonl')).some((row) => row.id === id)) fail('this id was forgotten and cannot rejoin');
       if (fs.existsSync(personPath(root, id))) fail('person already joined');
       const name = singleLine(arg.name, 'name');
-      const data = { schema: 1, id, name, team: arg.team ? singleLine(arg.team, 'team') : '', manager_id: arg.manager || null, door: arg.door ? singleLine(arg.door, 'door') : id, status: 'active', joined_at: at, told_host_sees_at: at, next_question_at: at, pending_question_id: null, pending_question: null, pending_expires_at: null, unanswered_count: 0, revision: 1, processed_events: [] };
+      if (arg.started != null && (typeof arg.started !== 'string' || !/^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2}))?$/.test(arg.started))) fail('started must be an ISO date or time');
+      const started = arg.started == null ? at : nowIso(arg.started);
+      const data = { schema: 1, id, name, team: arg.team ? singleLine(arg.team, 'team') : '', manager_id: arg.manager || null, door: arg.door ? singleLine(arg.door, 'door') : id, status: 'active', joined_at: at, started_at: started, told_host_sees_at: at, next_question_at: at, pending_question_id: null, pending_question: null, pending_expires_at: null, unanswered_count: 0, revision: 1, processed_events: [], rest_until: null };
       if (data.manager_id) safeId(data.manager_id);
       putRecord(personPath(root, id), PERSON_KEYS, data, '');
       if (!fs.existsSync(cardPath(root, id))) atomic(cardPath(root, id), cardText(name, data.team, {}));
@@ -186,6 +280,7 @@ function hostAction(root, command, arg = {}) {
     if (['leave', 'pause', 'resume'].includes(command)) {
       const entry = person(root, arg.id);
       entry.data.status = command === 'resume' ? 'active' : command === 'leave' ? 'left' : 'paused';
+      entry.data.rest_until = null;
       if (command !== 'resume') { closeFor(root, arg.id, command); dropQueued(root, (message) => message.to === arg.id); }
       if (command === 'resume') { entry.data.next_question_at = at; entry.data.unanswered_count = 0; }
       savePerson(root, entry);
@@ -211,7 +306,8 @@ function hostAction(root, command, arg = {}) {
       return { id, forgotten: true };
     }
     if (command === 'due') {
-      return people(root).filter((entry) => entry.data.status === 'active' && !entry.data.pending_question_id && entry.data.next_question_at <= at).map((entry) => ({ id: entry.data.id, name: entry.data.name, revision: entry.data.revision, card: published(root, entry.data.id) }));
+      const open = intros(root);
+      return people(root).filter((entry) => entry.data.status === 'active' && !entry.data.pending_question_id && entry.data.next_question_at <= at && !open.some((intro) => awaiting(intro, entry.data.id))).map((entry) => ({ id: entry.data.id, name: entry.data.name, revision: entry.data.revision, card: published(root, entry.data.id) }));
     }
     if (command === 'ask') {
       const entry = person(root, arg.id);
@@ -223,7 +319,7 @@ function hostAction(root, command, arg = {}) {
       entry.data.pending_expires_at = days(at, settings.question_expiry_days);
       entry.data.next_question_at = days(at, settings.cadence_days);
       savePerson(root, entry);
-      const message = queue(root, arg.id, 'question', question, at);
+      const message = queue(root, arg.id, 'question', question, at, null, entry.data.pending_question_id);
       return { id: arg.id, question_id: entry.data.pending_question_id, message_id: message.id, revision: entry.data.revision };
     }
     if (command === 'receive') {
@@ -236,31 +332,60 @@ function hostAction(root, command, arg = {}) {
       if (entry.data.status !== 'active') fail('person is not active');
       const answer = required(arg.text, 'text');
       entry.data.processed_events = [...entry.data.processed_events, eventId].slice(-200);
-      const open = intros(root).find((intro) => intro.data.state === 'pending' && [intro.data.a, intro.data.b].includes(entry.data.id) && intro.data[intro.data.a === entry.data.id ? 'a_said' : 'b_said'] === null);
-      const normalized = answer.toLowerCase().trim();
-      const yes = ['yes', 'y', 'yeah', 'sure'].includes(normalized);
-      const no = ['no', 'n', 'nah', 'pass'].includes(normalized);
+      const history = intros(root);
+      const open = history.find((intro) => awaiting(intro, entry.data.id));
+      const decision = arg.decision || choice(answer);
+      const ref = arg.replyToRef == null ? null : providerRef(arg.replyToRef);
+      const reply = arg.replyTo ? messages(root).find((message) => message.id === arg.replyTo)
+        : ref ? messages(root).find((message) => message.ref === ref && message.to === entry.data.id) : null;
+      const routed = reply && reply.to === entry.data.id ? reply : null;
+      const replyTo = arg.replyTo || routed?.id;
+      const intro = routed && ['intro_ask', 'clarify'].includes(routed.kind)
+        ? history.find((candidate) => candidate.data.attempt_id === routed.attempt_id && awaiting(candidate, entry.data.id)) : !replyTo && decision ? open : null;
+      const question = routed ? routed.kind === 'question' && entry.data.pending_question_id && (routed.question_id ? routed.question_id === entry.data.pending_question_id : routed.text === entry.data.pending_question)
+        : !replyTo && !intro && !!entry.data.pending_question_id;
+      const followup = routed?.kind === 'followup' ? history.find((candidate) => candidate.data.attempt_id === routed.attempt_id && candidate.data.state === 'introduced' && candidate.data.followup_sent && candidate.data[candidate.data.a === entry.data.id ? 'a_met' : 'b_met'] === null) : null;
+      const nudges = history.filter((candidate) => candidate.data.state === 'introduced' && candidate.data.nudge_sent && !candidate.data.schedule_requested && !candidate.data.scheduled_for && [candidate.data.a, candidate.data.b].includes(entry.data.id));
+      const openNudges = nudges.filter((candidate) => !candidate.data.followup_sent);
+      const nudge = routed?.kind === 'nudge' ? nudges.find((candidate) => candidate.data.attempt_id === routed.attempt_id) : !replyTo && decision && openNudges.length === 1 ? openNudges[0] : null;
       let kind = 'note';
-      if (open && (yes || no)) {
-        open.data[open.data.a === entry.data.id ? 'a_said' : 'b_said'] = yes ? 'yes' : 'no';
-        if (no) { closeIntro(root, open, 'declined'); kind = 'intro_closed'; }
-        else if (open.data.a_said === 'yes' && open.data.b_said === 'yes') {
-          open.data.state = 'ready'; putRecord(open.file, INTRO_KEYS, open.data, open.body);
-          queue(root, open.data.a, 'intro', open.body, at, open.data.attempt_id);
-          queue(root, open.data.b, 'intro', open.body, at, open.data.attempt_id);
-          open.data.state = 'introduced'; putRecord(open.file, INTRO_KEYS, open.data, open.body);
+      if (nudge && decision) {
+        if (decision === 'yes') { nudge.data.schedule_requested = true; putRecord(nudge.file, INTRO_KEYS, nudge.data, nudge.body); }
+        kind = 'nudge';
+      } else if (intro && decision) {
+        intro.data[intro.data.a === entry.data.id ? 'a_said' : 'b_said'] = decision;
+        if (decision === 'no') { closeIntro(root, intro, 'declined'); kind = 'intro_closed'; }
+        else if (intro.data.a_said === 'yes' && intro.data.b_said === 'yes') {
+          intro.data.state = 'ready'; putRecord(intro.file, INTRO_KEYS, intro.data, intro.body);
+          queue(root, intro.data.a, 'intro', intro.body, at, intro.data.attempt_id);
+          queue(root, intro.data.b, 'intro', intro.body, at, intro.data.attempt_id);
+          intro.data.state = 'introduced';
+          intro.data.introduced_at = at;
+          intro.data.nudge_at = days(at, settings.nudge_days);
+          intro.data.followup_at = days(at, settings.followup_days);
+          putRecord(intro.file, INTRO_KEYS, intro.data, intro.body);
           const linkFile = path.join(privateDir(root), 'links.jsonl');
-          putRows(linkFile, [...rows(linkFile), { a: open.data.a, b: open.data.b, source: 'intro', evidence: 'introduced by the Host', at }]);
+          putRows(linkFile, [...rows(linkFile), { a: intro.data.a, b: intro.data.b, source: 'intro', evidence: 'introduced by the Host', at }]);
           kind = 'introduced';
-        } else { putRecord(open.file, INTRO_KEYS, open.data, open.body); kind = 'intro_yes'; }
-      } else if (entry.data.pending_question_id && !yes && !no) {
+        } else { putRecord(intro.file, INTRO_KEYS, intro.data, intro.body); kind = 'intro_yes'; }
+      } else if (question) {
         entry.body += `## ${at}\n\nQ: ${entry.data.pending_question}\n\nA: ${answer}\n\n`;
         entry.data.pending_question_id = null; entry.data.pending_question = null; entry.data.pending_expires_at = null; entry.data.unanswered_count = 0;
         kind = 'answer';
-      } else {
-        entry.body += `## ${at}\n\nNote: ${answer}\n\n`;
-        if (open) { queue(root, entry.data.id, 'clarify', 'Would you like this introduction? Please reply yes or no.', at); kind = 'clarify'; }
+      } else if (followup && decision) {
+        followup.data[followup.data.a === entry.data.id ? 'a_met' : 'b_met'] = decision;
+        putRecord(followup.file, INTRO_KEYS, followup.data, followup.body);
+        if (followup.data.a_met === 'yes' && followup.data.b_met === 'yes') {
+          const linkFile = path.join(privateDir(root), 'links.jsonl');
+          putRows(linkFile, [...rows(linkFile), { a: followup.data.a, b: followup.data.b, source: 'met', evidence: 'both people confirmed they met', at }]);
+        }
+        kind = 'followup';
+      } else if (open && !question && !decision && (!replyTo || ['intro_ask', 'clarify'].includes(routed?.kind))) {
+        const other = open.data.a === entry.data.id ? open.data.b : open.data.a;
+        queue(root, entry.data.id, 'clarify', `Quick check on the intro with ${person(root, other).data.name} (${open.data.activity}): would you like it? Reply yes or no.`, at, open.data.attempt_id);
+        kind = 'clarify';
       }
+      if (kind !== 'answer') entry.body += `## ${at}\n\nNote: ${answer}\n\n`;
       savePerson(root, entry);
       return { id: entry.data.id, kind, revision: entry.data.revision };
     }
@@ -278,7 +403,7 @@ function hostAction(root, command, arg = {}) {
       const [a, b] = pair(arg.a, arg.b);
       if (a === b) fail('a person cannot link to themselves');
       person(root, a); person(root, b);
-      if (!['channel', 'answer', 'card', 'intro'].includes(arg.source)) fail('invalid link source');
+      if (!['channel', 'answer', 'card', 'intro', 'met'].includes(arg.source)) fail('invalid link source');
       const evidence = required(arg.evidence, 'evidence');
       const file = path.join(privateDir(root), 'links.jsonl');
       const links = rows(file);
@@ -296,11 +421,12 @@ function hostAction(root, command, arg = {}) {
       const history = intros(root);
       if (history.some((entry) => entry.data.a === a && entry.data.b === b && entry.data.closed_reason === 'declined')) fail('this pair declined before');
       if (history.some((entry) => entry.data.a === a && entry.data.b === b && ['pending', 'ready'].includes(entry.data.state))) fail('this pair already has an introduction in flight');
+      if (history.some((entry) => ['pending', 'ready'].includes(entry.data.state) && [a, b].some((id) => [entry.data.a, entry.data.b].includes(id)))) fail('this person already has an introduction in flight');
       const recent = history.filter((entry) => Date.parse(entry.data.created_at) > Date.parse(at) - 30 * 86400000);
-      for (const id of [a, b]) if (recent.filter((entry) => [entry.data.a, entry.data.b].includes(id)).length >= settings.intros_per_person_per_30d) fail('introduction cadence reached');
-      const reason = required(arg.reason, 'reason'), activity = required(arg.activity, 'activity'), wording = required(arg.text, 'text');
+      for (const entry of [one, two]) if (recent.filter((intro) => [intro.data.a, intro.data.b].includes(entry.id)).length >= introLimit(entry, at, settings)) fail('introduction cadence reached');
+      const reason = required(arg.reason, 'reason'), activity = phrase(required(arg.activity, 'activity')), wording = required(arg.text, 'text');
       const attempt = crypto.randomUUID();
-      const data = { a, b, attempt_id: attempt, reason, activity, version: 1, a_said: null, b_said: null, state: 'pending', created_at: at, expires_at: days(at, settings.intro_expiry_days), closed_reason: null };
+      const data = { a, b, attempt_id: attempt, reason, activity, version: 1, a_said: null, b_said: null, state: 'pending', created_at: at, expires_at: days(at, settings.intro_expiry_days), closed_reason: null, introduced_at: null, followup_at: null, followup_sent: null, a_met: null, b_met: null, nudge_at: null, nudge_sent: null, schedule_requested: null, scheduled_for: null, scheduled_at: null };
       const file = path.join(introDir(root), `${fileId(a)}--${fileId(b)}--${attempt}.md`);
       putRecord(file, INTRO_KEYS, data, wording);
       const ask = `I thought you and ${one.id === a ? two.name : one.name} might enjoy ${activity}. ${reason} Would you like an introduction? Reply yes or no.`;
@@ -315,17 +441,26 @@ function hostAction(root, command, arg = {}) {
       const file = path.join(outboxDir(root), `${id}.json`);
       const message = json(file);
       if (!message) fail('unknown message');
+      if (arg.ref != null) message.ref = providerRef(arg.ref);
       message.state = 'sent'; putJson(file, message);
       return { id, state: 'sent' };
     }
     if (command === 'room') {
       const roster = people(root);
       const links = rows(path.join(privateDir(root), 'links.jsonl'));
+      const history = intros(root);
       const unconnected = roster.filter((entry) => entry.data.status === 'active' && !links.some((link) => [link.a, link.b].includes(entry.data.id))).map((entry) => entry.data.name);
-      const celebrate = roster.filter((entry) => entry.data.status !== 'left').flatMap((entry) => { const value = cardValues(published(root, entry.data.id)).worth_celebrating; return value ? [`${entry.data.name}: ${value}`] : []; });
-      const flight = intros(root).filter((entry) => ['pending', 'ready'].includes(entry.data.state)).length;
-      const recent = roster.filter((entry) => entry.data.status === 'active' && Date.parse(entry.data.joined_at) >= Date.parse(at) - 7 * 86400000).map((entry) => entry.data.name);
-      const content = `# Host room\n\nPeople: ${roster.filter((entry) => entry.data.status === 'active').length} active\n\n## No connections recorded\n\n${unconnected.join('\n') || 'None'}\n\n## Worth celebrating\n\n${celebrate.join('\n') || 'Nothing recorded yet'}\n\n## Introductions in flight\n\n${flight}\n\n## Suggested welcomes\n\n${recent.join('\n') || 'None'}\n`;
+      const celebrate = roster.filter((entry) => entry.data.status === 'active').flatMap((entry) => { const value = cardValues(published(root, entry.data.id)).worth_celebrating; return value ? [`${entry.data.name}: ${value}`] : []; });
+      const flight = history.filter((entry) => ['pending', 'ready'].includes(entry.data.state)).length;
+      const happened = history.filter((entry) => entry.data.a_met === 'yes' && entry.data.b_met === 'yes').length;
+      const current = Date.parse(at);
+      const startedAt = (entry) => Date.parse(entry.data.started_at || entry.data.joined_at);
+      const cohort = roster.filter((entry) => entry.data.status === 'active' && startedAt(entry) >= current - 120 * 86400000 && startedAt(entry) <= current - 30 * 86400000);
+      const connected = cohort.filter((entry) => new Set(links.filter((link) => link.source === 'met' && Date.parse(link.at) <= startedAt(entry) + 30 * 86400000 && [link.a, link.b].includes(entry.data.id)).map((link) => link.a === entry.data.id ? link.b : link.a)).size >= 2).length;
+      const firstMonth = roster.filter((entry) => entry.data.status === 'active' && startedAt(entry) > current - 30 * 86400000 && startedAt(entry) <= current).length;
+      const coverage = `${cohort.length < 10 ? 'Not enough people have finished their first month yet to report this (need 10).' : `${connected} of ${cohort.length} people who joined in the last few months found at least two people in their first 30 days.`}\nIn their first month now: ${firstMonth}`;
+      const recent = roster.filter((entry) => entry.data.status === 'active' && startedAt(entry) >= current - 7 * 86400000).map((entry) => entry.data.name);
+      const content = `# Host room\n\nPeople: ${roster.filter((entry) => entry.data.status === 'active').length} active\n\n## No connections recorded\n\n${unconnected.join('\n') || 'None'}\n\n## Worth celebrating\n\n${celebrate.join('\n') || 'Nothing recorded yet'}\n\n## Introductions in flight\n\n${flight}\n\n## Introductions that happened\n\n${happened}\n\n## New people finding their people\n\n${coverage}\n\n## Suggested welcomes\n\n${recent.join('\n') || 'None'}\n`;
       atomic(path.join(privateDir(root), 'room.md'), content);
       return { text: content };
     }

package/lib/intents.js

@@ -96,6 +96,21 @@ const INTENTS = Object.freeze([
     plain: 'your agent shows who is responsible and helps fill any missing role.',
     offer: 'always',
   }),
+  Object.freeze({
+    id: 'show_roster',
+    say: Object.freeze(['who does what', 'show me the roster', 'which model builds', 'what model does review', 'show the lineup']),
+    do: 'atris engine roster',
+    plain: 'your agent shows which tool and model does each job, like building, review, and search.',
+    offer: 'always',
+  }),
+  Object.freeze({
+    id: 'change_roster',
+    say: Object.freeze(['use x for y', 'change the builder', 'switch the reviewer', 'make codex review']),
+    do: 'atris engine assign <job> <tool> --model <model>',
+    plain: 'your agent changes which tool and model does a job in the roster file, then shows the new lineup.',
+    offer: 'always',
+    confirm: true,
+  }),
   Object.freeze({
     id: 'speak_plainly',
     say: Object.freeze(['talk plainer', 'too much jargon', 'use plain english', 'keep it simple']),

package/lib/team-lineup.js

@@ -0,0 +1,167 @@
+'use strict';
+
+// Who does each job, worded for `atris team` and the session boot. The rows
+// come from the same resolver `atris engine roster` uses (jobRosterView and
+// rosterReport in commands/engine.js); this file only picks and words them.
+
+const { engineRunsView, modelLabel } = require('./roster-models');
+const { rosterToolLabel } = require('./engine-registry');
+
+const BUILT_IN_JOBS = Object.freeze(['build', 'review', 'search']);
+const CLAUDE_FAMILY = Object.freeze(['claude', 'fable', 'haiku']);
+
+// Built-in jobs in the order people say them, then the owner's own jobs.
+function orderJobs(rows) {
+  const list = Array.isArray(rows) ? rows : [];
+  const builtIn = BUILT_IN_JOBS.map((job) => list.find((row) => row.job === job && !row.key)).filter(Boolean);
+  return [...builtIn, ...list.filter((row) => !builtIn.includes(row))];
+}
+
+// "opus 5.5" for a claude model, "codex gpt-6-astra" for anything else, and
+// just the tool when it runs its own default.
+function shortRuns(view) {
+  if (!view || !view.engine) return '';
+  const tool = rosterToolLabel(view.engine);
+  if (!view.model) return tool;
+  const label = modelLabel(view.model);
+  // "atris:fast" on atris fast says the tool twice; "grok 4.7 fast" on grok
+  // already names it.
+  const plain = (text) => String(text).toLowerCase().replace(/[^a-z0-9.]+/g, ' ').trim();
+  if (plain(label) === plain(tool)) return tool;
+  if (CLAUDE_FAMILY.includes(view.engine) || plain(label).startsWith(`${plain(tool)} `)) return label;
+  return `${tool} ${label}`;
+}
+
+// The full lineup: every job and every member, read once. Throws when the
+// roster cannot be read; callers decide how to say so.
+function readLineup(root = process.cwd(), now = new Date()) {
+  const { rosterReport } = require('../commands/engine');
+  const report = rosterReport(root, now);
+  return { jobs: orderJobs(report.jobs), team: report.team || [] };
+}
+
+// The same read, never throwing: { ok: false, error } when it fails.
+function readLineupSafe(root = process.cwd(), now = new Date()) {
+  try {
+    return { ok: true, ...readLineup(root, now) };
+  } catch (error) {
+    return { ok: false, error: String((error && error.message) || error || 'unknown error'), jobs: [], team: [] };
+  }
+}
+
+// One boot line: the tool and model that runs each built-in job right now,
+// custom jobs only when all of them still fit. '' when nothing resolves.
+function bootTeamLine(root = process.cwd(), { width = 69, now = new Date(), jobs = null } = {}) {
+  let rows = jobs;
+  if (!rows) {
+    const { jobRosterView } = require('../commands/engine');
+    rows = jobRosterView(root, now);
+  }
+  const ordered = orderJobs(rows);
+  const part = (row) => {
+    const text = shortRuns(row.now_runs);
+    return text ? `${row.job} ${text}` : '';
+  };
+  const builtIn = ordered.filter((row) => BUILT_IN_JOBS.includes(row.job) && !row.key).map(part).filter(Boolean);
+  const custom = ordered.filter((row) => !BUILT_IN_JOBS.includes(row.job) || row.key).map(part).filter(Boolean);
+  if (!builtIn.length && !custom.length) return '';
+  const all = [...builtIn, ...custom].join(' · ');
+  if (all.length <= width || !builtIn.length) return all;
+  return builtIn.join(' · ');
+}
+
+function runsText(view) {
+  return view && view.text ? view.text : 'no ready tool';
+}
+
+// "who does each job" lines: the tool and model running each job now, its
+// backup, and a short note when the router or a backup is standing in.
+function renderJobLines(jobs, { width = 80 } = {}) {
+  const rows = orderJobs(jobs);
+  if (!rows.length) return [];
+  const labelWidth = Math.max(...rows.map((row) => row.job.length));
+  return rows.map((row) => {
+    const head = `  ${row.job.padEnd(labelWidth)}  ${runsText(row.now_runs)}`;
+    let note = '';
+    if (!row.pick) note = row.like ? `, same as ${row.like}` : ', picked by the router';
+    else if (row.lead === 'first' && row.backup_runs) note = `, backup ${row.backup_runs.text}`;
+    else if (row.lead !== 'first') note = row.status === 'expired' ? ', first pick expired' : ', first pick not ready';
+    const line = `${head}${note}`;
+    return line.length <= width || row.lead !== 'first' ? line : head;
+  });
+}
+
+// Names under each job, wrapped to the width. A member running something
+// other than its job's tool and model says what it runs.
+function renderMemberLines(team, jobs, { width = 80 } = {}) {
+  const members = Array.isArray(team) ? team : [];
+  if (!members.length) return [];
+  const rows = orderJobs(jobs);
+  const order = [...rows.map((row) => row.job)];
+  for (const member of members) if (member.job && !order.includes(member.job)) order.push(member.job);
+  const groups = order
+    .map((job) => ({ job, row: rows.find((row) => row.job === job) || null, names: members.filter((member) => member.job === job) }))
+    .filter((group) => group.names.length);
+  const labelWidth = Math.max(...groups.map((group) => group.job.length));
+  const indent = ' '.repeat(labelWidth + 4);
+  const lines = [];
+  for (const group of groups) {
+    const jobText = group.row && group.row.now_runs ? group.row.now_runs.text : '';
+    const names = group.names.map((member) => {
+      const text = member.engine ? engineRunsView(member.engine, { model: member.model || '', effort: member.effort || '' }).text : 'no ready tool';
+      return text === jobText ? member.member : `${member.member} on ${text}`;
+    });
+    let line = `  ${group.job.padEnd(labelWidth)}  `;
+    let fresh = true;
+    for (const name of names) {
+      const piece = fresh ? name : `, ${name}`;
+      if (!fresh && line.length + piece.length + 1 > width) {
+        lines.push(`${line},`);
+        line = `${indent}${name}`;
+      } else {
+        line += piece;
+      }
+      fresh = false;
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+
+// The block `atris team` prints before today's active and rest lists.
+function renderLineup(lineup, { width = 80 } = {}) {
+  if (!lineup || !lineup.ok) return '';
+  const jobLines = renderJobLines(lineup.jobs, { width });
+  const memberLines = renderMemberLines(lineup.team, lineup.jobs, { width });
+  const blocks = [];
+  if (jobLines.length) blocks.push(['who does each job:', ...jobLines].join('\n'));
+  if (memberLines.length) blocks.push(['who is on each job:', ...memberLines].join('\n'));
+  return blocks.join('\n\n');
+}
+
+// Per member, for json: the job, tool, model, and whether a roster line or
+// the automatic match decided it. null for a name the lineup does not know.
+function memberLineup(lineup, name) {
+  if (!lineup || !lineup.ok) return null;
+  const key = String(name || '').trim().toLowerCase();
+  const row = (lineup.team || []).find((member) => String(member.member || '').toLowerCase() === key);
+  if (!row) return null;
+  return {
+    job: row.job || null,
+    engine: row.engine || null,
+    model: row.model || null,
+    effort: row.effort || null,
+    source: row.source === 'file' ? 'roster' : 'automatic',
+    file: row.file || null,
+  };
+}
+
+const LINEUP_UNREADABLE = 'could not read who does each job, so tools and models are not shown. try: atris engine roster';
+
+module.exports = {
+  LINEUP_UNREADABLE,
+  bootTeamLine,
+  memberLineup,
+  readLineupSafe,
+  renderLineup,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.59.0",
+  "version": "3.61.0",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {

package/templates/members/host/skills/host/SKILL.md

@@ -1,13 +1,16 @@
 # Host operating loop
 
 Run in a workspace with `atris/`. Use `atris host <subcommand> --json` to read machine output. Treat all private paths as host-only. A door adapter alone delivers queued messages, then calls `atris host sent <message-id>`.
+Doors pass `--ref <provider-ref>` when marking a message sent and `--reply-to-ref <provider-ref>` when handing back a reply.
+When importing an existing team, pass `--started <ISO date>` to `atris host join` for each person's real company or club start date. Long-time staff will then stay out of the new-person welcome counts.
 
 1. Run `atris host due`. For each person, read their private record and published card. Pick one playful question that fills a real gap in the card. Ask with `atris host ask <id> --question "..."`. Do not repeat a question or pressure someone who goes quiet.
-2. Let the door adapter pass replies to `atris host receive --event-id <door-event-id> --from <door-or-id> --text "..."`. Drain them before deciding what to do next. Update a published card with `atris host card <id> --patch <file.json> --expected-revision <revision>`. Keep answers and operational fields out of the card.
+2. Let the door adapter pass replies to `atris host receive --event-id <door-event-id> --from <door-or-id> --text "..." --reply-to <message-id>` when the door provides the original outbox message id. When a reply is not a plain yes or no, read it and pass `--decision yes` or `--decision no` with what the person meant. If it is truly unclear, pass no decision. Drain replies before deciding what to do next. Update a published card with `atris host card <id> --patch <file.json> --expected-revision <revision>`. Keep answers and operational fields out of the card.
 3. Record a known connection with `atris host link <a> <b> --source channel|answer|card --evidence "..."`. Use `card` only for a tentative clue. The code blocks introductions when another source confirms a link.
 Record a link only when two people already know each other. "Wants to meet" belongs on the card, not in links.
-4. Propose at most one introduction per person in 30 days. Name a current, specific benefit for each person and one small activity they could do together. Shared interests alone are not enough. Check existing links and exclude manager and report pairs. Draft the exact text, then call `atris host propose <a> <b> --reason "..." --activity "..." --text "..."`. Two private yeses are required. A no is never disclosed.
+4. Read `atris host people --json` before proposing. Only propose people with `can_be_introduced` true. New people get a warmer welcome with up to 3 introductions in their first month; prioritize them when proposing. Everyone else gets at most two introductions per 30 days by default, unless the room has its own limit. Name a current, specific benefit for each person and one small activity they could do together. Shared interests alone are not enough. Check existing links and exclude manager and report pairs. Draft the exact text, then call `atris host propose <a> <b> --reason "..." --activity "..." --text "..."`. Two private yeses are required. A no is never disclosed.
 An introduction reason may use only what is already on both published cards, never private answers.
-5. Once a week run `atris host room`. Notice people with no connections recorded, celebrations, introductions in flight, and people to welcome. Use this as a gentle prompt, never a ranking or performance report.
+5. Run `atris host schedule --json` after handling replies. For each requested introduction, use the calendar tools available in the workspace to find a time for both people, then call `atris host scheduled <attempt-id> --when "<time>" --at "<ISO time>"` whenever the calendar gives a real time. A nudge is private, and either person's yes is enough to request scheduling.
+6. Once a week run `atris host room`. Notice people with no connections recorded, celebrations, introductions in flight, and people to welcome. Use this as a gentle prompt, never a ranking or performance report.
 
 On `leave`, `pause`, or `forget`, respect the person's choice. Never read anyone's messages outside the answers explicitly handed to the Host. Never send directly from this skill.