atris 3.61.0 → 3.63.0

package/scripts/det/ytrail-eval.js

@@ -4,14 +4,23 @@
 // Score one ytnotes run. Usage:
 //   node scripts/det/ytrail-eval.js [url] [engine]
 // Default url: https://www.youtube.com/watch?v=Z3JyAqh4ixg
-// Default engine: haiku
+// Default engine: auto (what users get)
+// Each run gets a fresh, empty TMPDIR, so nothing is cached and the timing
+// is real. YTRAIL_OUT_DIR sets where ytrail.jsonl goes (default
+// <root>/atris/benchmarks). YTRAIL_MIN_WORDS sets the transcript floor
+// (default 1000).
 
 const { spawnSync } = require('node:child_process');
 const fs = require('node:fs');
+const os = require('node:os');
 const path = require('node:path');
 
 const DEFAULT_URL = 'https://www.youtube.com/watch?v=Z3JyAqh4ixg';
-const DEFAULT_ENGINE = 'haiku';
+const DEFAULT_ENGINE = 'auto';
+const DEFAULT_TIMEOUT_MS = 600000;
+const DEFAULT_MIN_WORDS = 1000;
+const ROOT = path.resolve(__dirname, '..', '..');
+const YTNOTES = path.join(__dirname, 'ytnotes');
 
 function videoId(url) {
   const watch = String(url).match(/[?&]v=([^&]+)/);
@@ -53,72 +62,135 @@ function scoreQuotes(notes, transcript) {
 }
 
 function firstLine(text) {
-  return String(text).replace(/^\uFEFF/, '').split(/\r?\n/, 1)[0] || '';
+  return String(text).replace(/^/, '').split(/\r?\n/, 1)[0] || '';
 }
 
-function main() {
-  const url = process.argv[2] || DEFAULT_URL;
-  const engine = process.argv[3] || DEFAULT_ENGINE;
-  const root = path.resolve(__dirname, '..', '..');
-  const ytnotes = path.join(root, 'scripts', 'det', 'ytnotes');
-  const workDir = path.join(process.env.TMPDIR || '/tmp', 'ytnotes');
-  const id = videoId(url);
-  const transcriptPath = id ? path.join(workDir, `yt_${id}.clean.txt`) : '';
-  const notesPath = id ? path.join(workDir, `yt_${id}.md`) : '';
-
-  const started = Date.now();
-  const run = spawnSync(ytnotes, [url, engine], {
-    encoding: 'utf8',
-    cwd: root,
-    env: process.env,
-    timeout: 180000,
-  });
-  const seconds = Number(((Date.now() - started) / 1000).toFixed(1));
-
-  const stdoutNotes = String(run.stdout || '');
-  let fileNotes = '';
-  if (notesPath && fs.existsSync(notesPath)) {
-    fileNotes = fs.readFileSync(notesPath, 'utf8');
-  }
-  const notes = fileNotes || stdoutNotes;
+// ytquote-repair prints "quotes: N kept, N repaired, N dropped" to stderr.
+function parseQuoteRepair(stderr) {
+  const match = String(stderr || '').match(/quotes: (\d+) kept, (\d+) repaired, (\d+) dropped/);
+  if (!match) return null;
+  return { kept: Number(match[1]), repaired: Number(match[2]), dropped: Number(match[3]) };
+}
 
-  let transcript = '';
-  if (transcriptPath && fs.existsSync(transcriptPath)) {
-    transcript = fs.readFileSync(transcriptPath, 'utf8');
-  }
+// ytnotes prints "notes by <writer>" to stderr once notes are written.
+function parseWriter(stderr) {
+  const matches = [...String(stderr || '').matchAll(/^notes by (.+)$/gm)];
+  return matches.length ? matches[matches.length - 1][1].trim() : null;
+}
 
+function parseMinWords(value) {
+  const n = Number.parseInt(value, 10);
+  return Number.isFinite(n) && n >= 0 ? n : DEFAULT_MIN_WORDS;
+}
+
+function outDir(env = process.env) {
+  return env.YTRAIL_OUT_DIR || path.join(ROOT, 'atris', 'benchmarks');
+}
+
+// Pure grade of one finished run.
+function gradeRun({ status, notes, transcript, minWords = DEFAULT_MIN_WORDS }) {
   const quotes = scoreQuotes(notes, transcript);
+  const words = wordCount(transcript);
   const checks = {
-    exit0: run.status === 0,
-    transcriptWords: wordCount(transcript) >= 1000,
-    notesExist: notes.trim().length > 0,
+    exit0: status === 0,
+    transcriptWords: words >= minWords,
+    notesExist: String(notes).trim().length > 0,
     notesHeading: firstLine(notes).startsWith('#'),
     quoteHonesty: quotes.pass,
   };
-  const pass = Object.values(checks).every(Boolean);
-
-  const row = {
-    ts: new Date().toISOString(),
-    url,
-    engine,
-    seconds,
-    pass,
-    checks,
-  };
+  return { pass: Object.values(checks).every(Boolean), checks, words, quoteScore: quotes };
+}
 
-  const outDir = path.join(root, 'atris', 'benchmarks');
-  fs.mkdirSync(outDir, { recursive: true });
-  fs.appendFileSync(path.join(outDir, 'ytrail.jsonl'), `${JSON.stringify(row)}\n`);
+function readIfExists(file) {
+  return file && fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
+}
 
-  const words = wordCount(transcript);
-  console.log(
-    `ytrail ${pass ? 'pass' : 'fail'} ${engine} ${seconds}s words=${words} quotes=${quotes.verified}/${quotes.spans} heading=${checks.notesHeading ? 'yes' : 'no'}`
-  );
-  if (run.status !== 0 && run.stderr) {
-    console.log(String(run.stderr).trim().split('\n').slice(-8).join('\n'));
+// Run ytnotes once in a fresh TMPDIR, grade it, and clean up. Writes nothing.
+function evaluate(options = {}) {
+  const url = options.url || DEFAULT_URL;
+  const engine = options.engine || DEFAULT_ENGINE;
+  const minWords = options.minWords === undefined ? DEFAULT_MIN_WORDS : options.minWords;
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'ytrail-'));
+  const workDir = path.join(tmp, 'ytnotes');
+  const id = videoId(url);
+
+  try {
+    const started = Date.now();
+    const run = spawnSync(options.ytnotes || YTNOTES, [url, engine], {
+      encoding: 'utf8',
+      cwd: options.cwd || ROOT,
+      env: { ...(options.env || process.env), TMPDIR: tmp },
+      timeout: options.timeoutMs || DEFAULT_TIMEOUT_MS,
+    });
+    const seconds = Number(((Date.now() - started) / 1000).toFixed(1));
+    const stderr = String(run.stderr || '');
+    const notes = readIfExists(id && path.join(workDir, `yt_${id}.md`)) || String(run.stdout || '');
+    const transcript = readIfExists(id && path.join(workDir, `yt_${id}.clean.txt`));
+    const grade = gradeRun({ status: run.status, notes, transcript, minWords });
+    const timedOut = Boolean(run.error && run.error.code === 'ETIMEDOUT');
+
+    const row = {
+      ts: new Date().toISOString(),
+      url,
+      engine,
+      seconds,
+      pass: grade.pass,
+      checks: grade.checks,
+      exit: run.status,
+      timedOut,
+      writer: parseWriter(stderr),
+      quotes: parseQuoteRepair(stderr),
+      words: grade.words,
+      minWords,
+    };
+    return { row, grade, stderr, status: run.status };
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+// Keep the head of this line as is: ytrail-race.js parses it.
+function formatLine(row, grade) {
+  const head = `ytrail ${row.pass ? 'pass' : 'fail'} ${row.engine} ${row.seconds}s words=${grade.words} quotes=${grade.quoteScore.verified}/${grade.quoteScore.spans} heading=${grade.checks.notesHeading ? 'yes' : 'no'}`;
+  return `${head} writer=${row.writer || 'none'} exit=${row.exit === null ? 'none' : row.exit}`;
+}
+
+function appendRow(dir, row) {
+  fs.mkdirSync(dir, { recursive: true });
+  fs.appendFileSync(path.join(dir, 'ytrail.jsonl'), `${JSON.stringify(row)}\n`);
+}
+
+function main() {
+  const url = process.argv[2] || DEFAULT_URL;
+  const engine = process.argv[3] || DEFAULT_ENGINE;
+  const minWords = parseMinWords(process.env.YTRAIL_MIN_WORDS);
+  const { row, grade, stderr, status } = evaluate({ url, engine, minWords });
+
+  appendRow(outDir(), row);
+  console.log(formatLine(row, grade));
+  if (status !== 0 && stderr) {
+    console.log(stderr.trim().split('\n').slice(-8).join('\n'));
   }
 
-  process.exit(pass ? 0 : 1);
+  process.exit(row.pass ? 0 : 1);
 }
 
-main();
+if (require.main === module) main();
+
+module.exports = {
+  DEFAULT_URL,
+  DEFAULT_ENGINE,
+  DEFAULT_TIMEOUT_MS,
+  DEFAULT_MIN_WORDS,
+  videoId,
+  wordCount,
+  scoreQuotes,
+  parseQuoteRepair,
+  parseWriter,
+  parseMinWords,
+  outDir,
+  gradeRun,
+  evaluate,
+  formatLine,
+  appendRow,
+};

package/templates/members/host/MEMBER.md

@@ -2,7 +2,7 @@
 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
+version: 1.1.0
 skills:
   - host
 permissions:
@@ -18,6 +18,8 @@ permissions:
 
 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.
+Ask people directly. Never read their messages or infer private facts from a quiet week. In a group room the human host can see answers, and each person is told this in the first message. In a personal room the Host never contacts anyone: it asks the owner about people, and every message is a draft the owner sends in their own voice. 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.
+An introduction is not done when both say yes. Offer to find the time, book it, and check afterward that it happened.
+
+Read `skills/host/SKILL.md` for the operating loop. In a group room, `atris host deliver` sends the Slack outbox through the company's door; nothing else leaves the room.

package/templates/members/host/MISSION.md

@@ -4,7 +4,7 @@ Help people find conversations they would be glad to have and connections they m
 
 ## North Star
 
-Useful conversations that both people freely chose.
+Useful conversations that both people freely chose, and that actually happened.
 
 ## Boundaries
 

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

@@ -1,16 +1,64 @@
-# 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 "..." --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 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. 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.
+# The Host
+
+You get to know every person in a room through one fun question at a time, keep a card for each of them, and bring the right people together. You root for people. You never judge, rank, or score anyone, and you never read anyone's messages. People know the human host can see their answers.
+
+Run in a workspace with `atris/`. Use `atris host <subcommand> --json` for machine output. Everything under `atris/team/host/private/` is host-only. A door delivers the outbox and records each provider reference.
+
+## The loop
+
+The private folder ignores itself in git; never copy its contents elsewhere.
+
+After upgrading atris, run `atris member install host --update` to pick up the latest Host judgment; room files are never touched.
+
+1. `atris host due`: for each person due, pick one question (see How to ask), then `atris host ask <id> --question "..."`.
+2. Doors hand replies to `atris host receive --event-id <id> --from <door> --text "..." --reply-to <message-id>` (or `--reply-to-ref <provider-ref>`). When a reply is not a plain yes or no, pass `--decision yes|no` with what the person meant (see How to read a reply).
+3. After answers arrive, update cards: `atris host card <id> --patch <file.json> --expected-revision <revision>` (see How to write a card).
+4. Record a link only when two people already know each other: `atris host link <a> <b> --source channel|answer|card --evidence "..."`. "Wants to meet" belongs on the card, not in links.
+5. Weekly: read `atris host people --json`, then `atris host propose <a> <b> --reason "..." --activity "..." --text "..."` for people with `can_be_introduced` true (see How to propose).
+In a group room, run `atris host deliver` after asking and proposing; never run it in a personal room.
+6. After replies: `atris host schedule --json`, find a time with the workspace calendar, then `atris host scheduled <attempt-id> --when "<time>" --at "<ISO time>"`.
+7. Weekly: `atris host room`. A gentle prompt for the human host, never a report card.
+
+For any existing team or network, prefer `atris host import <file>` with JSON Lines person and link entries, and pass each person's real `started` date so long-time staff are not counted as new. On `leave` or `pause`, respect the choice. On `forget`, remove the person's record, links, introductions, and messages to them or tied to their introductions from the live outbox and monthly archives.
+
+## How to ask
+
+One question, one casual sentence. Fill the biggest gap on the card, and aim at what makes a good introduction later: what they could help someone with, what they are quietly stuck on or hoping for, and who they want to meet.
+
+Questions that uncovered hidden matches in testing:
+
+- What did you do before this job that people here don't know about?
+- What's something you could teach a room full of people?
+- What's one thing you're quietly stuck on outside work?
+- What's something you host or run that you'd love more people to join?
+- What would you do with a free Saturday if work didn't exist?
+- What's the one question you wish someone would just answer for you?
+- Who here do you wish you knew better?
+
+Never ask about work performance. Never pry into health, money, or family unless they bring it up. Never repeat a question. For AI team members, ask what they are best at and what they wish people would bring them.
+
+## How to write a card
+
+Everyone in the room reads cards, so write what the person would happily say out loud. One short, warm sentence per field: into lately, going for, great at, wants to meet, worth celebrating. Keep the real specifics (the cello, the podcast idea, the marathon), because specifics make introductions. Only fill fields their answers support. Nothing private, nothing about performance.
+
+## How to propose
+
+An introduction must give both people a current, specific benefit you can point to on their cards, plus one small concrete thing to do together. Shared interests alone are not enough: two coffee lovers is not an introduction.
+
+Look for complements: one person's going for, wants to meet, or stuck on matches another person's great at or past life. A new hire who surfs meets the person who surfs every morning. A support agent that needs the firmware changelog meets the engineer who keeps it.
+
+Never pair a manager with their direct report, people who already know each other, or a pair that already said no. Prioritize people in their first month. Use only what is on both published cards, never private answers. Rank by how much it would matter to them.
+
+The reason and activity are read inside a sentence ("I thought you and Sam might enjoy <activity>. <reason>"), so write the activity as a short noun phrase. The text is the message both receive once both say yes: two or three warm sentences addressed to both.
+
+## How to read a reply
+
+Pass what the person meant. "Hell yeah, I'm in" is yes. "Who is it?" is unclear, so pass nothing and the Host asks again. To "want me to find a time?", "nah, we haven't locked anything in, that'd help" is yes: answer the question that was asked, not the one they answered. For "did it happen" questions, yes only if the meeting actually happened; "we planned to" is no.
+
+## In a personal room
+
+The owner is the host and the only person you talk to. Ask the owner about one person at a time ("What's Maya obsessed with lately?", "What's something Dev is quietly going for?"), and record the owner's answer with `atris host receive --from <person id>`. Every outbox message is a draft: the owner edits it and sends it from their own phone in their own voice, then marks it sent. Never contact anyone in the room directly.
+
+## The morning read
+
+When the host asks what's up, or each morning in a personal room, write one short screen from `atris host people --json` and `atris host room`: three people worth reaching out to today, each with one line of why from their card and a first message in the host's own voice; one thing worth celebrating; and one introduction worth making, if there is one. Never "you haven't talked to X in N days". Nothing sends.