atris 3.58.8 → 3.59.0

package/lib/roster-models.js

@@ -0,0 +1,179 @@
+'use strict';
+
+// What model and effort each roster line really runs, and where each came
+// from, so the roster view never shows an engine with a blank model. A pin
+// on the line wins; with no pin, codex reads the top of its own settings
+// file, claude-family engines run the atris default, and every other engine
+// rides its own default. Nothing here spawns an engine or goes online.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const {
+  RUNNER_PROFILE_DEFS,
+  RUNNER_PROFILE_ALIASES,
+  DEFAULT_CLAUDE_RUNNER_MODEL,
+} = require('./runner-command');
+
+const CLAUDE_FAMILY = Object.freeze(['claude', 'fable', 'haiku']);
+const ATRIS_PINNED = Object.freeze(['atris-fast', 'composer']);
+
+// ~/.codex/config.toml unless a path is given. Test runs never read the real
+// file unless they point at one on purpose.
+function codexConfigFile(options = {}) {
+  if (options.codexConfigPath) return options.codexConfigPath;
+  if (process.env.ATRIS_CODEX_CONFIG_PATH) return process.env.ATRIS_CODEX_CONFIG_PATH;
+  if (process.env.NODE_TEST_CONTEXT) return '';
+  return path.join(process.env.CODEX_HOME || path.join(os.homedir(), '.codex'), 'config.toml');
+}
+
+// The top-level model and model_reasoning_effort, the lines before the first
+// [section]. A tiny line reader, not a toml parser: anything else is ignored.
+function readCodexSettings(options = {}) {
+  const file = codexConfigFile(options);
+  if (!file) return {};
+  let text = '';
+  try {
+    text = fs.readFileSync(file, 'utf8');
+  } catch {
+    return {};
+  }
+  const settings = {};
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (line.startsWith('[')) break;
+    const match = /^(model|model_reasoning_effort)\s*=\s*(?:"([^"]*)"|'([^']*)')\s*(?:#.*)?$/.exec(line);
+    if (match) settings[match[1]] = (match[2] !== undefined ? match[2] : match[3]).trim();
+  }
+  return settings;
+}
+
+// claude-opus-5-5 reads as "opus 5.5"; anything else as written.
+function modelLabel(model) {
+  const text = String(model || '').trim();
+  const grok = /^grok-(\d+(?:\.\d+)?)(-build-fast)?$/.exec(text);
+  if (grok) return `grok ${grok[1]}${grok[2] ? ' fast' : ''}`;
+  const match = /^claude-(opus|sonnet|haiku|fable)-(\d+)(?:-(\d{1,2}))?(?:-\d{8})?$/.exec(text);
+  if (!match) return text;
+  return `${match[1]} ${match[2]}${match[3] ? `.${match[3]}` : ''}`;
+}
+
+const SOURCE_TAIL = Object.freeze({ 'codex settings': 'from codex settings', 'atris default': 'atris default' });
+const SOURCE_INLINE = Object.freeze({ 'codex settings': 'from codex settings', 'atris default': 'by atris default' });
+
+// One engine's real model and effort. Sources: roster (pinned on the line),
+// codex settings, atris default, or own default (the engine decides).
+function engineRunsView(engineId, { model = '', effort = '' } = {}, options = {}) {
+  const id = RUNNER_PROFILE_ALIASES[engineId] || engineId;
+  const def = RUNNER_PROFILE_DEFS[id] || {};
+  const view = { engine: id, model: '', model_source: 'own default', effort: '', effort_source: '' };
+  if (model) {
+    view.model = model;
+    view.model_source = 'roster';
+  } else if (id === 'codex') {
+    const settings = readCodexSettings(options);
+    if (settings.model) {
+      view.model = settings.model;
+      view.model_source = 'codex settings';
+    }
+  } else if (CLAUDE_FAMILY.includes(id)) {
+    view.model = String(process.env.ATRIS_RUNNER_MODEL || '').trim() || def.model || DEFAULT_CLAUDE_RUNNER_MODEL;
+    view.model_source = 'atris default';
+  } else if (ATRIS_PINNED.includes(id) && def.model) {
+    view.model = def.model;
+    view.model_source = 'atris default';
+  }
+  if (effort) {
+    view.effort = effort;
+    view.effort_source = 'roster';
+  } else if (id === 'codex') {
+    const settings = readCodexSettings(options);
+    if (settings.model_reasoning_effort) {
+      view.effort = settings.model_reasoning_effort;
+      view.effort_source = 'codex settings';
+    }
+  }
+  view.text = `${id} (${runsDetail(view)})`;
+  return view;
+}
+
+function runsDetail(view) {
+  const items = [{ text: view.model ? modelLabel(view.model) : 'its own default', source: view.model ? view.model_source : 'roster' }];
+  if (view.effort) items.push({ text: view.effort, source: view.effort_source });
+  const sourced = [...new Set(items.map((item) => item.source).filter((source) => SOURCE_TAIL[source]))];
+  // Every item shares one source: say it once at the end.
+  if (sourced.length === 1 && items.every((item) => item.source === sourced[0])) {
+    return [...items.map((item) => item.text), SOURCE_TAIL[sourced[0]]].join(', ');
+  }
+  return items.map((item) => (SOURCE_INLINE[item.source] ? `${item.text} ${SOURCE_INLINE[item.source]}` : item.text)).join(', ');
+}
+
+// --- what this machine offers --------------------------------------------
+//
+// Cheap local sources only: never the network, never the tool itself. Codex
+// keeps a cache of the models it can run; claude takes the names atris knows;
+// every other engine lists its seed models.
+
+const KNOWN_CLAUDE_MODELS = Object.freeze(['opus 5.5', 'opus 5', 'sonnet 5', 'haiku 4.5', 'fable 5.1']);
+
+// ~/.codex/models_cache.json unless a path is given. Test runs never read the
+// real file unless they point at one on purpose.
+function codexModelsCacheFile(options = {}) {
+  if (options.codexModelsCachePath) return options.codexModelsCachePath;
+  if (process.env.ATRIS_CODEX_MODELS_CACHE_PATH) return process.env.ATRIS_CODEX_MODELS_CACHE_PATH;
+  if (process.env.NODE_TEST_CONTEXT) return '';
+  return path.join(process.env.CODEX_HOME || path.join(os.homedir(), '.codex'), 'models_cache.json');
+}
+
+// Every "slug" in the cache, in order, once each. [] when there is no cache
+// or it does not parse.
+function readCodexModelSlugs(options = {}) {
+  const file = codexModelsCacheFile(options);
+  if (!file) return [];
+  let data;
+  try {
+    data = JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return [];
+  }
+  const slugs = [];
+  const walk = (value, depth) => {
+    if (depth > 6 || !value || typeof value !== 'object') return;
+    if (Array.isArray(value)) {
+      value.forEach((item) => walk(item, depth + 1));
+      return;
+    }
+    if (typeof value.slug === 'string' && value.slug.trim() && !slugs.includes(value.slug.trim())) slugs.push(value.slug.trim());
+    for (const child of Object.values(value)) if (child && typeof child === 'object') walk(child, depth + 1);
+  };
+  walk(data, 0);
+  return slugs;
+}
+
+function homeLabel(file) {
+  const home = os.homedir();
+  const rel = path.relative(home, file);
+  return rel && !rel.startsWith('..') && !path.isAbsolute(rel) ? `~/${rel}` : file;
+}
+
+// One row per installed engine: the models it offers and where that list
+// came from ("from <file>" or "known names").
+function availableModels(engines, options = {}) {
+  return (engines || []).map((engine) => {
+    const id = engine.id;
+    if (id === 'codex') {
+      const slugs = readCodexModelSlugs(options);
+      if (slugs.length) return { engine: id, models: slugs, source: `from ${homeLabel(codexModelsCacheFile(options))}` };
+    }
+    if (id === 'claude') return { engine: id, models: [...KNOWN_CLAUDE_MODELS], source: 'known names' };
+    const models = Array.isArray(engine.models) ? engine.models.filter(Boolean) : [];
+    return { engine: id, models, source: 'known names' };
+  });
+}
+
+module.exports = {
+  modelLabel,
+  readCodexSettings,
+  engineRunsView,
+  availableModels,
+};

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/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.59.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,13 @@
+# 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>`.
+
+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.
+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.
+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.
+
+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.