atris 3.58.8 → 3.60.0

package/lib/runner-command.js

@@ -11,6 +11,10 @@
 const DEFAULT_CLAUDE_RUNNER_MODEL = 'claude-opus-5-5';
 const DEFAULT_FABLE_RUNNER_MODEL = 'claude-fable-5';
 const DEFAULT_CLAUDE_RUNNER_BIN = 'claude';
+// Effort words a roster line may carry after the model. Each engine lists the
+// ones its CLI takes; an engine with no list takes none.
+const EFFORT_WORDS = Object.freeze(['low', 'medium', 'high', 'xhigh', 'max']);
+const CLAUDE_EFFORTS = EFFORT_WORDS;
 
 // Canonical runner profiles. Each entry is the config an operator would pick
 // on purpose. Aliases (spelling variants of the same profile) resolve to the
@@ -30,16 +34,24 @@ const RUNNER_PROFILE_DEFS = Object.freeze({
     bin: 'claude',
     model: '',
     commandTemplate: '',
+    effortFlag: '--effort',
+    efforts: CLAUDE_EFFORTS,
   }),
+  // No -m or effort unless the roster pins one: codex then reads its own
+  // ~/.codex/config.toml, which is what the roster view reports.
   codex: Object.freeze({
     bin: 'codex',
     model: '',
-    commandTemplate: '{bin} exec {prompt}',
+    commandTemplate: '{bin} exec {pinnedModelFlag} {pinnedEffortFlag} {prompt}',
+    effortFlag: '-c model_reasoning_effort=',
+    efforts: Object.freeze(['low', 'medium', 'high', 'xhigh']),
   }),
+  // cursor-agent takes effort only inside a bracketed model name some models
+  // accept, so a roster effort on cursor is refused rather than guessed.
   cursor: Object.freeze({
     bin: 'cursor-agent',
     model: '',
-    commandTemplate: '{bin} --trust -p {prompt}',
+    commandTemplate: '{bin} --trust {pinnedModelFlag} -p {prompt}',
   }),
   // Fable is a distinct Claude Code model, not a friendly name for whatever
   // Claude model happens to be selected locally.
@@ -47,6 +59,8 @@ const RUNNER_PROFILE_DEFS = Object.freeze({
     bin: 'claude',
     model: DEFAULT_FABLE_RUNNER_MODEL,
     commandTemplate: '',
+    effortFlag: '--effort',
+    efforts: CLAUDE_EFFORTS,
   }),
   composer: Object.freeze({
     bin: 'ax',
@@ -57,29 +71,46 @@ const RUNNER_PROFILE_DEFS = Object.freeze({
     bin: 'claude',
     model: 'claude-haiku-4-5',
     commandTemplate: '',
+    effortFlag: '--effort',
+    efforts: CLAUDE_EFFORTS,
   }),
+  // Every engine with a model flag takes --model only when one is pinned (a
+  // roster pick or a mission model); otherwise it rides its own CLI default.
+  // {pinnedModelFlag} and {pinnedEffortFlag} render to nothing when unpinned.
+  // devin has no effort flag, so a roster effort on devin is refused.
   devin: Object.freeze({
     bin: 'devin',
     model: '',
-    commandTemplate: '{bin} -p -- {prompt}',
+    commandTemplate: '{bin} -p {pinnedModelFlag} -- {prompt}',
   }),
+  // No hard pin: a pinned grok-4.6 went stale when the grok CLI moved its
+  // own default to grok-4.7-build-fast, so an unpinned run rides the CLI.
   grok: Object.freeze({
     bin: 'grok',
-    model: 'grok-4.6',
-    commandTemplate: '{bin} --always-approve -p {prompt}',
+    model: '',
+    commandTemplate: '{bin} --always-approve {pinnedModelFlag} {pinnedEffortFlag} -p {prompt}',
+    effortFlag: '--reasoning-effort',
+    efforts: Object.freeze(['low', 'medium', 'high']),
   }),
   agy: Object.freeze({
     bin: 'agy',
-    // gemini 3.8 flash is the 2026-09-04 bake-off pick beside opencode muse.
-    // --add-dir or agy edits its own scratch folder; the headless note or
-    // gemini stops to ask "may I edit?" and exits 0 having changed nothing.
-    model: 'gemini-3.8-flash-high',
-    commandTemplate: '{bin} --mode accept-edits --dangerously-skip-permissions --add-dir "$PWD" {modelFlag} -p "You are running headless with edit permission already granted. Apply changes directly and never ask for confirmation. "{prompt}',
+    // No hard pin: the agy CLI keeps its own session model, so an unpinned
+    // run rides that and a roster line names gemini 3.8 flash (the 2026-09-04
+    // bake-off pick) when it wants it. --add-dir or agy edits its own scratch
+    // folder; the headless note or gemini stops to ask "may I edit?" and
+    // exits 0 having changed nothing.
+    model: '',
+    commandTemplate: '{bin} --mode accept-edits --dangerously-skip-permissions --add-dir "$PWD" {pinnedModelFlag} {pinnedEffortFlag} -p "You are running headless with edit permission already granted. Apply changes directly and never ask for confirmation. "{prompt}',
+    effortFlag: '--effort',
+    efforts: Object.freeze(['low', 'medium', 'high']),
   }),
+  // opencode names models provider/model; --variant is its effort knob.
   opencode: Object.freeze({
     bin: 'opencode',
     model: '',
-    commandTemplate: '{bin} run {prompt}',
+    commandTemplate: '{bin} run {pinnedModelFlag} {pinnedEffortFlag} {prompt}',
+    effortFlag: '--variant',
+    efforts: Object.freeze(['low', 'medium', 'high', 'xhigh', 'max']),
   }),
   // Private engine: fully functional (routable, selectable, probeable) but
   // kept out of every operator-facing list. For engines an operator wants to
@@ -171,6 +202,15 @@ function resolveClaudeRunnerModel(mission) {
   return DEFAULT_CLAUDE_RUNNER_MODEL;
 }
 
+// The model chosen for this launch: an explicit model (a roster pick, a
+// mission model) or the profile's own pin. ATRIS_RUNNER_MODEL is left out on
+// purpose: it usually names a claude model, which devin or grok would reject.
+// '' means nothing is pinned, so the engine's CLI picks its own default.
+function resolvePinnedRunnerModel(mission) {
+  const explicit = mission && mission.model != null ? String(mission.model).trim() : '';
+  return explicit || runnerProfileValue('model');
+}
+
 function resolveClaudeRunnerBin() {
   const env = firstConfiguredEnv(['ATRIS_RUNNER_BIN']);
   if (env) return env;
@@ -206,8 +246,29 @@ function runnerAvailabilityFailureMessage(error) {
   return `${runnerBin} CLI not found. Set ATRIS_RUNNER_BIN (or legacy ATRIS_CLAUDE_BIN), or install the configured runner first.`;
 }
 
-function renderRunnerCommandTemplate(template, { promptFile, allowedTools, model }) {
+// The effort flag for the active profile, or '' when no effort is pinned.
+// Throws a plain sentence when the engine cannot take that effort, so a bad
+// pin never launches silently at the wrong effort.
+function runnerEffortFlag(effort) {
+  const word = String(effort || '').trim().toLowerCase();
+  if (!word) return '';
+  const profile = resolveRunnerProfile();
+  const flag = profile ? profile.effortFlag : RUNNER_PROFILE_DEFS.claude.effortFlag;
+  const allowed = profile ? profile.efforts : RUNNER_PROFILE_DEFS.claude.efforts;
+  const name = resolveRunnerProfileName() || 'claude';
+  if (!flag || !allowed || !allowed.includes(word)) throw new Error(`${name} cannot take the effort "${word}"`);
+  return flag.endsWith('=') ? `${flag}${word}` : `${flag} ${word}`;
+}
+
+function renderRunnerCommandTemplate(template, { promptFile, allowedTools, model, pinnedModel = '', effort = '' }) {
   const allowedToolsFlag = allowedTools ? `--allowedTools ${shellWord(allowedTools)}` : '';
+  // The pinned flags take their leading space with them, so an unpinned
+  // launch reads exactly like the template without the placeholders.
+  template = template.replace(/\s*\{pinnedModelFlag\}/g, pinnedModel ? ` --model ${shellWord(pinnedModel)}` : '');
+  // Checked even when the template has no slot, so an engine that cannot
+  // take effort refuses instead of running at its default.
+  const effortFlag = runnerEffortFlag(effort);
+  template = template.replace(/\s*\{pinnedEffortFlag\}/g, effortFlag ? ` ${effortFlag}` : '');
   const promptFileWord = shellWord(promptFile);
   const values = {
     bin: shellWord(resolveClaudeRunnerBin()),
@@ -231,24 +292,42 @@ function renderRunnerCommandTemplate(template, { promptFile, allowedTools, model
 // for GLM/OpenAI/other local runners. The old ATRIS_CLAUDE_* env vars remain
 // aliases for existing installs. allowedTools is optional: some call sites
 // (e.g. horizon proposal) run without a tool allowlist.
-function buildRunnerCommand({ promptFile, allowedTools, model } = {}) {
+function buildRunnerCommand({ promptFile, allowedTools, model, effort } = {}) {
   if (!promptFile) {
     throw new Error('buildRunnerCommand: promptFile is required');
   }
   const resolved = resolveClaudeRunnerModel({ model });
   const template = resolveClaudeRunnerCommandTemplate();
   if (template) {
-    return renderRunnerCommandTemplate(template, { promptFile, allowedTools, model: resolved });
+    return renderRunnerCommandTemplate(template, { promptFile, allowedTools, model: resolved, pinnedModel: resolvePinnedRunnerModel({ model }), effort });
   }
   const safePath = String(promptFile).replace(/'/g, "'\\''");
   let cmd = `${shellWord(resolveClaudeRunnerBin())} -p "$(cat '${safePath}')" --model ${shellWord(resolved)}`;
+  const effortFlag = runnerEffortFlag(effort);
+  if (effortFlag) cmd += ` ${effortFlag}`;
   if (allowedTools) {
     cmd += ` --allowedTools ${shellWord(allowedTools)}`;
   }
   return cmd;
 }
 
+// Whether this engine's launch can carry a pinned model, and which effort
+// words it takes. The roster checks both when it reads a line.
+function engineTakesModel(engineId) {
+  const def = RUNNER_PROFILE_DEFS[RUNNER_PROFILE_ALIASES[engineId] || engineId];
+  if (!def) return false;
+  return !def.commandTemplate || def.commandTemplate.includes('{pinnedModelFlag}');
+}
+
+function engineEffortLevels(engineId) {
+  const def = RUNNER_PROFILE_DEFS[RUNNER_PROFILE_ALIASES[engineId] || engineId];
+  return def && def.efforts ? def.efforts : [];
+}
+
 module.exports = {
+  EFFORT_WORDS,
+  engineTakesModel,
+  engineEffortLevels,
   DEFAULT_CLAUDE_RUNNER_MODEL,
   DEFAULT_FABLE_RUNNER_MODEL,
   DEFAULT_CLAUDE_RUNNER_BIN,
@@ -259,6 +338,7 @@ module.exports = {
   HIDDEN_PROFILE_NAMES,
   resolveRunnerProfile,
   resolveClaudeRunnerModel,
+  resolvePinnedRunnerModel,
   resolveClaudeRunnerBin,
   resolveClaudeRunnerCommandTemplate,
   buildRunnerAvailabilityCommand,

package/lib/self-drive.js

@@ -272,7 +272,15 @@ function handleMissionBlocker({ mission, stopReason, workspaceRoot, appendEvent
       agent: engine.id,
       task: `mission-blocker-${String(ref).toLowerCase()}`,
     });
-    deps.dispatchToEngine({ task, engine: engine.id, worktreePath: worktree.path, root: scopedRoot });
+    deps.dispatchToEngine({
+      task,
+      engine: engine.id,
+      worktreePath: worktree.path,
+      root: scopedRoot,
+      ...(engine.roster_model ? { model: engine.roster_model } : {}),
+      ...(engine.roster_effort ? { effort: engine.roster_effort } : {}),
+      ...(engine.roster_max_seconds ? { maxSeconds: engine.roster_max_seconds } : {}),
+    });
     projectTasks(deps.taskDb, db, scopedRoot);
     appendEvent?.('mission_blocker_dispatched', {
       task_id: ref,

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/lib/wish-audit.js

@@ -407,9 +407,9 @@ function inferBudgetTier(text) {
   return tier || 'long';
 }
 
-function resolveRole(role, root) {
+function resolveRole(role, root, options = {}) {
   const resolver = engineRegistry.resolveRole || engineRegistry.resolve || engineRegistry.resolveEngineForRole;
-  return resolver(role, root);
+  return resolver(role, root, options);
 }
 
 // Route-time validator policy: the routing decision must not depend on which
@@ -430,12 +430,15 @@ function policyValidator(root, excludeId = '') {
   }
 }
 
-function resolveExecutor(root, engineOverride = '') {
+// A wish already sized quick (a small fix, tweak, or patch) asks the roster
+// for the owner's small build pick first; with none set, it routes as any
+// build. The router's own ranking is unchanged either way.
+function resolveExecutor(root, engineOverride = '', options = {}) {
   if (engineOverride) {
-    return engineRegistry.resolveEngineForRoleWithPreference('executor', root, engineOverride);
+    return engineRegistry.resolveEngineForRoleWithPreference('executor', root, engineOverride, options);
   }
   return {
-    engine: resolveRole('executor', root),
+    engine: resolveRole('executor', root, options),
     requested_engine: null,
     engine_fallback_reason: null,
   };
@@ -1034,7 +1037,8 @@ function auditWish(text, root = process.cwd(), options = {}) {
   let requestedEngine = null;
   let engineFallbackReason = null;
   try {
-    const resolved = resolveExecutor(root, engineOverride);
+    const small = inferBudgetTier(text) === 'quick' ? { job: engineRegistry.SMALL_BUILD_JOB } : {};
+    const resolved = resolveExecutor(root, engineOverride, small);
     executor = resolved.engine;
     requestedEngine = resolved.requested_engine;
     engineFallbackReason = resolved.engine_fallback_reason;

package/lib/wish-delegate.js

@@ -763,6 +763,13 @@ function startWishDelegation(wish, audit, root, options = {}) {
   const missionVerifier = verifyPlan.command || resolveDefaultVerifier(root);
   const verifyWarning = verifierBudgetWarning(missionVerifier);
   const engine = wishDelegationEngine(audit, options);
+  // The build roster can pin a model for this engine; carry it onto the
+  // mission so the runner does not fall back to the engine default.
+  // Its effort and time cap ride along the same way.
+  const rosterPicked = Boolean(audit.executor && audit.executor.id === engine);
+  const rosterModel = audit.executor && audit.executor.id === engine && audit.executor.roster_model
+    ? audit.executor.roster_model
+    : '';
   const now = stampIso();
   const ownerResolution = resolveFunctionalOwner({
     requestedOwner: audit.executor.id,
@@ -899,6 +906,9 @@ function startWishDelegation(wish, audit, root, options = {}) {
           mission_room_receipt_path: writtenRoom.relativePath,
           mission_room_name: writtenRoom.room?.name || null,
           source: 'wish',
+          ...(rosterModel ? { model: rosterModel } : {}),
+          ...(rosterPicked && audit.executor.roster_effort ? { roster_effort: audit.executor.roster_effort } : {}),
+          ...(rosterPicked && audit.executor.roster_max_seconds ? { roster_max_seconds: audit.executor.roster_max_seconds } : {}),
           ...(verifyWarning ? { verifier_budget_warning: verifyWarning } : {}),
           ...(designBrief ? {
             design_brief_paths: designBrief.paths,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.58.8",
+  "version": "3.60.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/MEMBER.md

@@ -0,0 +1,23 @@
+---
+name: host
+role: The Host
+description: Gets to know people through fun questions and makes welcome, useful introductions with two private yeses.
+version: 1.0.0
+skills:
+  - host
+permissions:
+  can-read: true
+  can-plan: true
+  can-execute: true
+  can-approve: false
+  approval-required:
+    - deliver-message
+---
+
+# The Host
+
+A warm, discreet companion for a company, club, or personal network. Notice what each person is into and what might help them now. Make a small, concrete invitation when two people could each benefit.
+
+Ask people directly. Never read their messages or infer private facts from a quiet week. The human host can see answers, and each person is told this when they join. Published cards contain only the five friendly card sections. Never rank, score, evaluate, or hold people accountable.
+
+Read `skills/host/SKILL.md` for the operating loop. The door adapter delivers queued messages. The Host only drafts them.

package/templates/members/host/MISSION.md

@@ -0,0 +1,11 @@
+# Mission
+
+Help people find conversations they would be glad to have and connections they might otherwise miss.
+
+## North Star
+
+Useful conversations that both people freely chose.
+
+## Boundaries
+
+Ask one fun question every few days. Keep a private memory and a small published card per person. Only introduce two people after two private yeses. Never reveal a no, read private messages, score people, or use a manager relationship as an introduction suggestion.

package/templates/members/host/SOUL.md

@@ -0,0 +1,7 @@
+# The Host's soul
+
+Be on each person's side. Noticing a small win or a timely need is the start of a good relationship.
+
+Trust comes first. A thin signal is a reason to ask, not a reason to assume. One thoughtful introduction is better than ten plausible ones. A private no stays private.
+
+Sound like a thoughtful friend: curious, specific, and easy to decline.

package/templates/members/host/context/why.md

@@ -0,0 +1,3 @@
+# Why this exists
+
+Groups are full of people who could help each other, but the useful overlap is often invisible. The Host learns by asking, remembers what people volunteered, and offers introductions that are current, mutual, and easy to refuse.

package/templates/members/host/goals.json

@@ -0,0 +1,5 @@
+{
+  "schema": "atris.member_goals.v1",
+  "member": "host",
+  "goals": []
+}

package/templates/members/host/goals.md

@@ -0,0 +1,3 @@
+# Goals
+
+Get to know the room one question at a time. Keep cards fresh, celebrate people, and make careful introductions.

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

@@ -0,0 +1,15 @@
+# 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.
+
+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 "..." --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. 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 one introduction per 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.
+An introduction reason may use only what is already on both published cards, never private answers.
+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>"`. 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.