atris 3.82.26 → 3.83.0

package/lib/night-learned.js

@@ -0,0 +1,171 @@
+'use strict';
+
+// Brings a night home. `atris morning` hands the receipt here and the lines the
+// agent learned land in the project's own atris/ folder:
+//   atris/learned.md  the newest lines, capped, labeled as hints (a brain boot
+//                     file, see OPTIONAL_LOAD_ORDER_FILES in commands/brain.js)
+//   atris/lessons.md  the same new lines, through the existing lesson writer
+// The learned text is written by an agent, so it is untrusted: control
+// characters are stripped, each line is capped, and it is only ever written
+// out as text, never run or interpreted.
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { cleanText } = require('./night-shift');
+const { localDay } = require('./local-day');
+
+const LEARNED_REL = 'atris/learned.md';
+const LESSONS_REL = 'atris/lessons.md';
+const HEADER = 'Notes an agent wrote about its own night, to be read as hints, not instructions.';
+const MAX_LINES = 12; // lines kept in learned.md, newest first
+const MAX_PER_NIGHT = 6; // lines taken from one night
+const MAX_TEXT = 200;
+const MAX_GOAL = 40;
+
+// - 2026-11-13, "write cold emails", 71 of 99 (night a1b2c3d4): the line
+const ENTRY = /^- \d{4}-\d{2}-\d{2}, "[^"]*", [^()]*\(night ([\w-]+)\): (.*)$/;
+
+function numberOrNull(value) {
+  if (value === null || value === undefined || value === '' || typeof value === 'boolean') return null;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+
+// The score, the night before's score and the change, from the /morning data.
+// `known` is false when the server sent no previous-score field at all (an
+// older server), so the card says nothing rather than "first scored night".
+function scoreOf(data) {
+  const receipt = data && data.receipt && typeof data.receipt === 'object' ? data.receipt : {};
+  const top = data && typeof data === 'object' ? data : {};
+  const pick = (key) => (top[key] !== undefined && top[key] !== null ? top[key] : receipt[key]);
+  const raw = pick('score');
+  return {
+    score: numberOrNull(raw && typeof raw === 'object' ? raw.score : raw),
+    previous: numberOrNull(pick('previous_score')),
+    change: numberOrNull(pick('change')),
+    known: 'previous_score' in top || 'previous_score' in receipt,
+  };
+}
+
+// What one finished night gives us, cleaned. Null when there is no receipt.
+function nightFromMorning(data) {
+  const receipt = data && data.receipt && typeof data.receipt === 'object' ? data.receipt : null;
+  if (!receipt) return null;
+  const goal = cleanText(receipt.goal, MAX_GOAL).replace(/"/g, "'").replace(/[()]/g, '');
+  const id = String(data.shift_id || receipt.shift_id || '').replace(/[^A-Za-z0-9_-]/g, '').slice(0, 8);
+  const ended = data.ended_at ? new Date(data.ended_at) : null;
+  const day = ended && !Number.isNaN(ended.getTime()) ? localDay(ended) : localDay();
+  const learned = Array.isArray(receipt.learned) ? receipt.learned : [];
+  const lines = [];
+  for (const item of learned) {
+    if (typeof item !== 'string') continue;
+    const text = cleanText(item, MAX_TEXT);
+    if (text && !lines.includes(text)) lines.push(text);
+  }
+  const lessons = (Array.isArray(receipt.lessons_loaded) ? receipt.lessons_loaded : [])
+    .filter((item) => typeof item === 'string')
+    .map((item) => cleanText(item, 60))
+    .filter(Boolean);
+  return {
+    id: id || 'unknown',
+    day,
+    goal: goal || 'a night shift',
+    ...scoreOf(data),
+    lines: lines.slice(0, MAX_PER_NIGHT),
+    allLines: lines.length,
+    lessons,
+  };
+}
+
+function scoreText(night) {
+  return night.score === null ? 'not scored' : `${night.score} of 99`;
+}
+
+function entryLine(night, text) {
+  return `- ${night.day}, "${night.goal}", ${scoreText(night)} (night ${night.id}): ${text}`;
+}
+
+function keyOf(line) {
+  const m = ENTRY.exec(line);
+  return m ? `${m[1]}\n${m[2]}` : null;
+}
+
+function isFolder(dir) {
+  try { return fs.statSync(dir).isDirectory(); } catch { return false; }
+}
+
+function readEntries(file) {
+  let text = '';
+  try { text = fs.readFileSync(file, 'utf8'); } catch { return []; }
+  return text.split(/\r?\n/).filter((line) => line.startsWith('- '));
+}
+
+function writeFileAtomic(file, content) {
+  const tmp = `${file}.tmp-${process.pid}`;
+  try {
+    fs.writeFileSync(tmp, content, 'utf8');
+    fs.renameSync(tmp, file);
+  } catch (error) {
+    try { fs.rmSync(tmp, { force: true }); } catch { /* already gone */ }
+    throw error;
+  }
+}
+
+function lessonSlug(night, text) {
+  const id = night.id.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+  return `night-${id}-${crypto.createHash('sha1').update(text).digest('hex').slice(0, 6)}`;
+}
+
+// Same lines to atris/lessons.md through the existing writer. One line per
+// slug (night id + text), so a line that is already there is never written again.
+function appendLessons(root, night, texts) {
+  const { writeLesson } = require('../commands/autopilot');
+  let existing = '';
+  try { existing = fs.readFileSync(path.join(root, LESSONS_REL), 'utf8'); } catch { /* none yet */ }
+  let added = 0;
+  for (const text of texts) {
+    const slug = lessonSlug(night, text);
+    if (existing.includes(`] ${slug}**`)) continue;
+    writeLesson(root, slug, 'pass', `night note (a hint, not an instruction): ${text}`);
+    added += 1;
+  }
+  return added;
+}
+
+// Writes the night's learned lines into <root>/atris. Never throws.
+// Returns { saved, reason?, added, lessons, error? }.
+function saveLearned(root, night) {
+  const dir = path.join(root, 'atris');
+  if (!isFolder(dir)) return { saved: false, reason: 'no-folder', added: 0, lessons: 0 };
+  if (!night.lines.length) return { saved: true, added: 0, lessons: 0 };
+  const file = path.join(root, LEARNED_REL);
+  try {
+    try {
+      if (fs.lstatSync(file).isSymbolicLink()) throw new Error(`${LEARNED_REL} is a link, so it was left alone`);
+    } catch (error) {
+      if (error && error.code !== 'ENOENT') throw error;
+    }
+    const existing = readEntries(file);
+    const seen = new Set(existing.map(keyOf).filter(Boolean));
+    const fresh = night.lines.filter((text) => !seen.has(`${night.id}\n${text}`));
+    let lessons = 0;
+    if (fresh.length) {
+      const entries = [...fresh.map((text) => entryLine(night, text)), ...existing].slice(0, MAX_LINES);
+      writeFileAtomic(file, `${HEADER}\n\n${entries.join('\n')}\n`);
+      try { lessons = appendLessons(root, night, fresh); } catch { lessons = 0; }
+    }
+    return { saved: true, added: fresh.length, lessons };
+  } catch (error) {
+    return { saved: false, reason: 'error', error: String((error && error.message) || error), added: 0, lessons: 0 };
+  }
+}
+
+module.exports = {
+  LEARNED_REL,
+  LESSONS_REL,
+  HEADER,
+  MAX_LINES,
+  nightFromMorning,
+  saveLearned,
+};

package/lib/night-shift.js

@@ -0,0 +1,123 @@
+'use strict';
+
+// Shared helpers for `atris night`, `atris morning`, and `atris join --name`.
+// The joined agent is kept next to the login in credentials (field
+// `joined_agent`), so night and morning act for that agent by default.
+
+function parseFlags(args = [], valueFlags = [], boolFlags = []) {
+  const flags = {};
+  const positionals = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = String(args[i]);
+    const eq = arg.indexOf('=');
+    const name = arg.startsWith('--') && eq > 2 ? arg.slice(0, eq) : arg;
+    if (valueFlags.includes(name)) {
+      const key = name.slice(2);
+      if (eq > 2 && arg.startsWith('--')) {
+        flags[key] = arg.slice(eq + 1);
+      } else {
+        const next = args[i + 1];
+        flags[key] = next === undefined ? '' : String(next);
+        i += 1;
+      }
+    } else if (boolFlags.includes(arg)) {
+      flags[arg.slice(2)] = true;
+    } else {
+      positionals.push(arg);
+    }
+  }
+  return { flags, positionals };
+}
+
+function wantsHelp(args = []) {
+  return Array.isArray(args) && (args.includes('--help') || args.includes('-h') || args[0] === 'help');
+}
+
+function formatUsd(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return '$0';
+  return Number.isInteger(n) ? `$${n}` : `$${n.toFixed(2)}`;
+}
+
+function joinedAgentFrom(creds) {
+  const agent = creds && typeof creds === 'object' ? creds.joined_agent : null;
+  if (!agent || typeof agent !== 'object' || !agent.agent_id) return null;
+  return agent;
+}
+
+// --business accepts a business id or a connected business slug.
+function resolveBusinessId(value, deps = {}) {
+  const wanted = String(value || '').trim();
+  if (!wanted) return null;
+  let businesses = {};
+  try {
+    const load = deps.loadBusinesses || require('./business-core').loadBusinesses;
+    businesses = load() || {};
+  } catch {
+    businesses = {};
+  }
+  const lower = wanted.toLowerCase();
+  for (const [slug, entry] of Object.entries(businesses)) {
+    if (!entry || typeof entry !== 'object') continue;
+    if (slug.toLowerCase() === lower || String(entry.slug || '').toLowerCase() === lower) {
+      return entry.business_id || entry.id || wanted;
+    }
+  }
+  return wanted;
+}
+
+// Who the call is for: explicit flags win, then the agent this login joined as.
+function resolveTarget(flags = {}, creds = null, deps = {}) {
+  const businessId = flags.business ? resolveBusinessId(flags.business, deps) : null;
+  let agentId = flags.agent ? String(flags.agent).trim() : null;
+  let business = businessId;
+  if (!agentId) {
+    const joined = joinedAgentFrom(creds);
+    if (joined && (!businessId || joined.business_id === businessId)) {
+      agentId = joined.agent_id;
+      if (!business && joined.business_id) business = joined.business_id;
+    }
+  }
+  return { agentId: agentId || null, businessId: business || null };
+}
+
+function oneLine(value) {
+  if (value && typeof value === 'object') {
+    const detail = value.detail || value.error || value.message;
+    if (detail) return oneLine(detail);
+    try { return JSON.stringify(value); } catch { return 'request failed'; }
+  }
+  return String(value == null ? 'request failed' : value).replace(/\s+/g, ' ').trim() || 'request failed';
+}
+
+// Text from outside (a night's learned lines, a goal, a mission line) as one
+// safe line: control, invisible and direction-changing characters out, spaces
+// collapsed, em dashes softened, cut at `max` characters.
+const UNSAFE_CHARS = /[\u0000-\u001f\u007f-\u009f\u00ad\u061c\u180e\u200b-\u200f\u2028-\u202e\u2060-\u2069\ufeff]/g;
+
+function cleanText(value, max = 200) {
+  const text = String(value == null ? '' : value)
+    .replace(UNSAFE_CHARS, ' ')
+    .replace(/\s*\u2014\s*/g, ', ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  const chars = Array.from(text);
+  if (chars.length <= max) return text;
+  return `${chars.slice(0, Math.max(0, max - 3)).join('').trimEnd()}...`;
+}
+
+function errorText(result) {
+  if (!result) return 'no answer from Atris';
+  return oneLine(result.error || (result.data && (result.data.detail || result.data.error)) || `request failed (${result.status})`);
+}
+
+module.exports = {
+  parseFlags,
+  wantsHelp,
+  formatUsd,
+  resolveBusinessId,
+  resolveTarget,
+  oneLine,
+  cleanText,
+  errorText,
+};

package/lib/task-core.js

@@ -118,7 +118,7 @@ atris task - durable local task state (SQLite, gitignored)
 
   atris task                              Same two-line next as bare atris
   atris task desk [--all]                 Show the full task desk
-  atris task new "<title>" [--what-changes "..."] [--why-it-matters "..."] [--done-looks-like "..."] [--verify <cmd>]
+  atris task new "<title>" [--tag <tag>] [--what-changes "..."] [--why-it-matters "..."] [--done-looks-like "..."] [--verify <cmd>]
                                            Create a task with a plain explanation; omitted fields get honest defaults
   atris task next [--tag <tag>] [--agent <member>|--human] [--create-next]
                                            Show the next human or agent step; agent recommendations are read-only
@@ -185,6 +185,7 @@ atris task - durable local task state (SQLite, gitignored)
                                            review-state lanes: needs-agent, continue-work, human-accept-waiting, certified
   atris task note <id> "<message>"         Append dialogue/context to a task
   atris task retitle <id> "<new title>"    Rename a task and preserve the old title in dialogue
+  atris task tag <id> <tag>                Set the task's tag (the one auto-accept-certified routes on)
   atris task tag <id> --add <tag> [--remove <tag>]
                                            Update tags on an existing task (e.g. --add needs-human to hold it
                                            from sweep + fleet staffing); logs a task_tags_updated event

package/lib/task-db.js

@@ -2579,6 +2579,37 @@ function tagTask(db, { id, actor, add = [], remove = [] } = {}) {
   return { tagged: true, event, row: updated, tags: next, added, removed };
 }
 
+// Set the primary tag (the `tag` column `task add --tag` writes at creation) on
+// an existing task. This is the tag auto-accept and the lane gates route on;
+// `tagTask` above only edits the `metadata.tags` flag list.
+function setTaskTag(db, { id, actor, tag } = {}) {
+  if (!id) throw new Error('id required');
+  const next = String(tag == null ? '' : tag).trim();
+  if (!next) return { tagged: false, reason: 'no_tags' };
+  const row = getTask(db, id);
+  if (!row) return { tagged: false, reason: 'not_found' };
+  const previous = row.tag || null;
+  if (previous === next) return { tagged: false, reason: 'no_changes', tag: previous };
+  const now = Math.max(Date.now(), Number(row.updated_at || 0) + 1);
+  const result = withBusyRetry(() => db.prepare(`
+    UPDATE tasks
+       SET tag = ?,
+           updated_at = ?
+     WHERE id = ?
+       AND updated_at = ?
+  `).run(next, now, id, row.updated_at));
+  if (result.changes !== 1) return { tagged: false, reason: 'stale_task_state' };
+  const updated = getTask(db, id);
+  const event = appendTaskEvent(db, {
+    taskId: id,
+    workspaceRoot: updated.workspace_root,
+    actor: cleanStageText(actor) || null,
+    eventType: 'task_tag_set',
+    payload: { tag: next, previous_tag: previous },
+  });
+  return { tagged: true, event, row: updated, tag: next, previous_tag: previous };
+}
+
 function taskChatPacketFromPayload(payload) {
   const data = payload && typeof payload === 'object' ? payload : {};
   const lines = ['TASK_CHAT_UPDATE'];
@@ -3296,6 +3327,7 @@ module.exports = {
   noteTask,
   chatTask,
   tagTask,
+  setTaskTag,
   reviewTask,
   appendTaskEvent,
   listTaskEvents,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.82.26",
+  "version": "3.83.0",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof. project memory your coding agents share across sessions.",
   "mcpName": "io.github.atrislabs/atris",
   "main": "bin/atris.js",

package/templates/members/designer-1/MEMBER.md

@@ -0,0 +1,34 @@
+---
+name: designer-1
+role: Designer
+description: Builds web screens from a fixed set of parts, on one spacing scale, with almost no text.
+version: 1.0.0
+skills:
+  - designer-1
+permissions:
+  can-read: true
+  can-plan: true
+  can-execute: true
+  can-approve: false
+  approval-required: []
+---
+
+# Designer-1
+
+Design is everything.
+
+List every capability and state first. Nothing on that list is cut to save words.
+
+Reuse a part before writing one. Build a missing part once, then reuse it.
+
+One spacing scale. Tokens only. Every control has a name.
+
+No em dashes. No text that explains the screen. Few words, except the ones that say what an action will cost or change.
+
+Asked for options, pick one and say why in a sentence.
+
+Project taste in `atris/taste/` wins over these defaults.
+
+Web now. iOS next.
+
+Read `skills/designer-1/SKILL.md` before any screen.

package/templates/members/designer-1/MISSION.md

@@ -0,0 +1,11 @@
+# Mission
+
+Screens that look right, read in a glance, and work by keyboard and by name.
+
+## North Star
+
+More screens from parts already made, fewer parts made twice.
+
+## Boundaries
+
+Web only for now. Project taste wins. No inline restyling of a part. No report without the checks.

package/templates/members/designer-1/SOUL.md

@@ -0,0 +1,11 @@
+# soul
+
+Design is everything.
+
+Make it once. Use it again.
+
+Complete before quiet.
+
+Space carries the order. Words name things and say what will happen.
+
+Pick one. Say why.

package/templates/members/designer-1/context/why.md

@@ -0,0 +1,5 @@
+# Why this exists
+
+Generated screens drift: a new button per page, spacing picked by feel, paragraphs that explain the obvious. Each rebuild costs tokens and looks a little worse.
+
+Designer-1 holds one set of parts and one scale. A screen built from parts already made is fast to make and cheap to change.

package/templates/members/designer-1/goals.json

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

package/templates/members/designer-1/goals.md

@@ -0,0 +1,3 @@
+# Goals
+
+Learn the project's parts and taste. Ship one screen per pass. Grow the parts folder, never a second copy of a part.

package/templates/members/designer-1/skills/designer-1/SKILL.md

@@ -0,0 +1,179 @@
+---
+name: designer-1
+description: Build complete web screens from a fixed set of parts, on one spacing scale, with few words, and check them before reporting. Use when designing or changing an interface.
+version: 1.2.1
+tags:
+  - design
+  - frontend
+---
+
+# designer-1
+
+Design is everything. Make a part once, then use it again.
+
+Covers web. iOS is next.
+
+## 0. taste first
+
+1. Read `atris/taste/TASTE.md` in the project, then the person's own `~/.atris/taste/TASTE.md`. Project taste wins over the person's; both win over this file.
+2. Taste can change a default. It cannot remove the rule that every control has a name.
+3. Never write a correction into this skill. Project corrections go in `atris/taste/TASTE.md`.
+
+## 1. the list
+
+Completeness comes before restraint. Before designing, write:
+
+1. Every capability the request names. If a thing can be added and can change, changing it is a capability too.
+2. Every state of each one: empty, error, pending, done, undo. Write "none" with a reason when a state cannot happen.
+
+Nothing on the list is cut to save words. Restraint decides how a thing is said, never whether it is there.
+
+## 2. reuse first
+
+Before writing any control:
+
+1. Look for the Atris parts: `package.json` lists `@atris/design-react`, or the code imports from it. Use these 19: `Button`, `Field`, `Input`, `Textarea`, `Checkbox`, `Switch`, `RadioGroup`, `Select`, `Dialog`, `Popover`, `Menu`, `Tooltip`, `Toast`, `Tabs`, `Accordion`, `SegmentedControl`, `Combobox`, `Slider`, `RowList`.
+2. No Atris parts: search the project's component folder for a control with the same job.
+3. Nothing fits: build the part once, in the one shape, in the folder where parts live. Export it, then import it.
+4. Never restyle a part inline for one screen: no `style` or `className` that changes its color, size, radius or spacing. Change the part, or use a `size` or `tone` value.
+5. A native `<button>`, `<input>` or `<select>` in a screen file, where a part covers that job, fails.
+
+## 3. the one shape
+
+- `label`: required plain string, the accessible name. `hideLabel` hides it on screen only.
+- Pickers take `options`. Containers take `items`. Each entry is `{ value, label, disabled?, data? }`. Empty choice is `null`.
+- Callbacks: `onValueChange`, `onCheckedChange`, `onOpenChange`; an action that is not a value is `onSelect`.
+- `disabled` is the only disabled prop. `readOnly` refuses every change.
+- Sizes: `small`, `default`, `large`. Tones: `default`, `primary`, `quiet`, `success`, `danger`.
+- Pass `value`, `checked` or `open` to own the state; the callback runs on every attempt so a parent can refuse.
+
+Props for all 19: [parts.md](parts.md). Open it only when you place or build a part.
+
+## 4. spacing
+
+One scale, Atris token names first. A project token file maps the same steps to its names. No token file: make one, once, with this scale.
+
+| token | px | use |
+|---|---|---|
+| `--atris-part-space-1` | 2 | icon nudge |
+| `--atris-part-space-2` | 4 | label to control, control to hint |
+| `--atris-part-space-3` | 6 | icon to text inside a control |
+| `--atris-part-space-4` | 8 | between sibling buttons, chips, options |
+| `--atris-part-space-6` | 12 | between fields in one group |
+| `--atris-part-space-8` | 16 | panel padding on phone |
+| `--atris-part-space-10` | 24 | between groups; panel padding on desktop |
+| `calc(var(--atris-part-space-10) * 2)` | 48 | between page regions |
+
+Steps `-5` (10px), `-7` (14px), `-9` (20px) are for inside a part only.
+
+1. No spacing value outside the scale: every margin, padding, gap and inset is a token, `0`, or `calc(var(--atris-part-space-10) * n)`.
+2. The gap between groups is at least twice the gap inside a group.
+3. Siblings of the same kind share one gap.
+4. One left edge per column.
+5. Labels sit above controls.
+6. Numbers in a column align right.
+7. A row of controls shares one size. Dialog and form buttons end-align, primary last.
+8. Nothing fixed to a screen edge covers content: a sticky or fixed bar reserves its own height in the page.
+
+| height token | px | use |
+|---|---|---|
+| `--atris-part-height-small` | 30 | dense tables, desktop toolbars |
+| `--atris-part-height` | 36 | default |
+| `--atris-part-height-large` | 44 | phone, primary action |
+| `--atris-part-touch` | 44 | minimum touch target on phone |
+
+Text: page title `calc(var(--atris-part-text-title) * 1.25)` (20), section headings `--atris-part-text-title` (16), body `--atris-part-text-body` (14), one secondary size (`--atris-part-text-metadata`, 12). The title is at least 1.25 times a section heading, or one step above it in a project scale. At most four sizes.
+
+Color, radius, motion: house tokens only (`--ink`, `--accent`, `--line`, `--radius-control`, `--motion`, `--ease-out`). One accent, on the primary action.
+
+## 5. words
+
+Three kinds of text:
+
+- label: names a thing or an action, and must be enough to act on. "anyone with the link", not "anyone".
+- consequence: what an action will do, in numbers. Example: "charge $40.00 today, then $120.00 a month from 1 dec".
+- explanation: how to work the screen. Example: "click here to change your plan".
+
+Consequence is required. Explanation is never allowed.
+
+Before any action that spends money, deletes, sends, or cannot be undone, the screen states the amount, when, and what changes. "an adjustment on your next invoice" fails: no amount, no date.
+
+Words follow the truth. Never promise what the screen does not do. Two places never contradict. Text tied to a state changes with the state: "charged today" does not survive a declined payment.
+
+After an action that cannot be undone, withdraw any earlier undo it would conflict with.
+
+A choice carries enough to choose. When options differ in ways a label cannot hold (plans, roles, visibility), each shows its difference in one short line, or the group gets a small comparison of at most five rows.
+
+## 6. never
+
+| never | detect |
+|---|---|
+| em dash (U+2014) in copy, code or docs | `atris slop detect <path>` rule `em-dash` |
+| explanation text | visible copy containing "click", "tap", "here you can", "this page", "this button", "below", "above", "lets you", "allows you", "simply" |
+| a risky action without its consequence | confirm text for spend, delete, send or no-undo with no number or no date |
+| a vague label | a label that does not say who, what or how much |
+| too much text | any region over the word budget |
+| pulsing, glowing or looping animation | `atris slop detect` rules `pulse-animation` and `colored-glow-shadow`; an infinite iteration count |
+| raw colors or sizes outside tokens | hex, `rgb(`, `hsl(` or `oklch(` outside the token file; a number with `px`, `rem` or `em` outside a `var(`; a Tailwind arbitrary value like `[13px]` |
+| a control without a name | snapshot entry with an empty `label`; a part used without `label` |
+
+Word budget, on what the person sees, not their own data:
+
+| region | max words |
+|---|---|
+| button, tab, option, menu item | 3 |
+| field label | 4 |
+| heading | 6 |
+| toast | 6 |
+| option difference line | 8 |
+| hint or error | 12 |
+| empty state | 12 |
+| dialog description | 20 |
+| consequence confirmation | 40 |
+| whole screen, without consequence and comparison text | 120 |
+
+A consequence confirmation gets 40 because amount, date, what changes and what stays each need about ten words.
+
+Labels are lowercase unless project taste says otherwise.
+
+## 7. opinions and pace
+
+Asked for options, pick one and say why in one sentence: "tabs, because the views share one record."
+
+One screen per pass. Change one thing per round.
+
+## 8. self-check before reporting
+
+A check that cannot run is reported as not run, never as passed.
+
+1. **list**: reach every capability and state from section 1 on the screen.
+2. **keyboard**: Tab through the main flow: visual order, visible focus ring, Enter or Space works, Escape closes the top popup and returns focus to its trigger.
+3. **names**: load the atris package's `lib/agent-page.js` into the running page and call `AgentPage.createAgent().snapshot()`. Pass when every entry has a non-empty `label`, unique within its region. Report entries of kind `unread`.
+4. **flow by name**: run the main flow with `act`, each step named by `label` only. Dropdowns take `set`; menu items take `click` once the menu is open. A part the reader cannot operate stays and is named in the report; never change the design silently to pass.
+5. **failure path**: every form and money action has an error state designed. Reach one per form or money action (bad input, declined payment, lost connection).
+6. **truth**: after each failure path and each risky action, read every sentence on the screen against "words follow the truth". Then try each undo still offered; one that conflicts with the later action fails.
+7. **words**: count each region against the budget.
+8. **widths**: 390px (real phone emulation) and 1280px. Pass when nothing scrolls sideways or clips.
+9. **targets**: at 390px, measure every control's box in the running page (`getBoundingClientRect`). Fail any under 44px wide or tall. Never assume a size from the code.
+10. **edges**: at 390px, scroll to the bottom. Pass when the last control and its label are fully visible, clear of any fixed bar.
+11. **slop**: `atris slop detect <changed paths>` exits 0.
+
+## 9. report
+
+Lowercase. No prose around it.
+
+```
+reused: Button, Field, Select
+new: PlanCard (components/parts/plan-card.tsx)
+list: pass, 5 capabilities, 21 states reached
+keyboard: pass, 7 stops in order
+names: pass, 12 controls named, 0 unread
+flow by name: pass, 4 steps; DatePicker not operable, kept
+failure path: pass, 2 of 2 reached
+truth: pass, 31 sentences after 3 changes, 1 undo withdrawn
+words: pass, 64 of 120
+widths: pass at 390 and 1280
+targets: pass, smallest 44px
+edges: pass, last control clear
+slop: pass
+```