atris 3.30.1 → 3.30.3

package/AGENTS.md

@@ -61,6 +61,12 @@ Always-on agents should move proof-backed work to Review, complete their native
 goal, then continue the mission loop with the next goal. They must not run
 `atris task accept` or claim AgentXP unless a human approved the proof.
 
+Codex agents with native goal tools should run `atris mission goal --json`
+before choosing work. If the payload includes `goal.visible_goal`, mirror
+`goal.objective` into the visible chat goal when the current goal is empty,
+complete, or already matching; never complete unrelated active goals just to
+make room.
+
 ## Workflow
 
 ```

package/atris/AGENTS.md

@@ -14,6 +14,11 @@ task truth, proof, review, and backend/cloud sync all flow through Atris.
 4. Track work with `atris task`; use `atris/TODO.md` only as the rendered fallback view.
 5. Preferred loop: `atris plan` → `atris do` → `atris review`.
 
+Task owners are functional or feature members, not engines. Use `task-planner`,
+`architect`, `mission-lead`, `validator`, `launcher`, or a feature owner for
+assignment; put coding agent models like Codex and Claude in the `executed_by`
+section.
+
 ## Mission Autonomy
 
 Use `atris mission` when work should survive this chat or run as an autonomous loop.
@@ -51,6 +56,12 @@ Always-on agents should move proof-backed work to Review, complete their native
 goal, then continue the mission loop with the next goal. They must not run
 `atris task accept` or claim Career XP unless a human approved the proof.
 
+Codex agents with native goal tools should run `atris mission goal --json`
+before choosing work. If the payload includes `goal.visible_goal`, mirror
+`goal.objective` into the visible chat goal when the current goal is empty,
+complete, or already matching; never complete unrelated active goals just to
+make room.
+
 Do not write new operating doctrine here first. Add it to Atris policy, skills,
 wiki, or `atris/atris.md`, then regenerate this adapter if needed.
 

package/atris/CLAUDE.md

@@ -36,6 +36,11 @@ Atris is the source of truth. This file is only an adapter for Claude Code; do n
 
 Before edits, claim or create one small task with `atris task`, read `atris/MAP.md`, and write the goal/files/done/check contract into task dialogue. After edits, move proof-backed work to Review with `atris task ready <id> --proof "<commands or receipt>"`; chat-only proof does not count.
 
+Task owners are functional or feature members, not engines. Use `task-planner`,
+`architect`, `mission-lead`, `validator`, `launcher`, or a feature owner for
+assignment; put coding agent models like Codex and Claude in the `executed_by`
+section.
+
 Native goals and task approval are separate gates:
 
 ```text

package/atris/atris.md

@@ -70,11 +70,11 @@ Core loop:
 
 ```bash
 atris task list
-atris task delegate "<title>" --to <owner> --tag <tag>
-atris task delegate "<title>" --to <owner> --via swarlo --tag <tag>
+atris task delegate "<title>" --to <functional-member> --tag <tag>
+atris task delegate "<title>" --to <functional-member> --executed-by <engine> --via swarlo --tag <tag>
 atris task day
 atris task next
-atris task claim <id> --as <agent>
+atris task claim <id> --as <functional-member>
 atris task note <id> "<context, blocker, decision, or handoff>"
 atris task finish <id> --proof "<tests, screenshot, diff, or receipt>"
 atris task review <id> --lesson "<what improved>" --next "<next task>"
@@ -89,7 +89,7 @@ Every task record should carry:
 
 ```
 Title: <small work packet>
-Owner: <agent or unclaimed>
+Owner: <functional or feature member, not an engine>
 Objective: <why this matters>
 Context: <links/files/decisions>
 Exit: <observable done condition>
@@ -97,6 +97,21 @@ Verify: <shell command or concrete proof>
 Next: <suggested follow-up task>
 ```
 
+Task planning preview and landing:
+
+```
+Owner: <functional-member>
+Plan: <one sentence on the intended change>
+Done: <observable result>
+Check: <verifier, receipt, or artifact proof>
+```
+
+Owner is accountable company role (`task-planner`, `architect`, `mission-lead`,
+`validator`, `launcher`, or a feature owner). Coding agent models like Codex and
+Claude are not task owners; put them in the `executed_by` section when useful.
+If no existing member fits, create a member-creation task instead of assigning
+broad work to an engine or generic executor.
+
 | Field | Meaning | Enforcement |
 |---|---|---|
 | tier | `agent` proceeds, `gray` queues for approval, `human` never attempted by you | guarded |

package/atris/policies/atris-design.md

@@ -17,6 +17,32 @@ this is the "distribution center" — statistically average, aesthetically dead.
 
 ---
 
+## vocabulary is the lever
+
+designers get better results from AI than engineers do. not because they're more creative — because they own the **language of craft**. an engineer says "make it look nice." a designer says "tighten the vertical rhythm, increase negative space, make the hierarchy bolder here and quieter there."
+
+the model can only aim at the words you give it. **name the move you want, precisely, in craft vocabulary.** vague prompts produce vague output.
+
+core terms to use when directing AI:
+- **vertical rhythm** — spacing consistency down the page, locked to a baseline grid
+- **negative space** — intentional emptiness as a design element, not absence
+- **bolder / quieter** — relative emphasis, not absolute size
+- **affordances** — visual cues that signal interaction (and now: agentic affordances for AI users)
+- **meta-design** — designing the *system* of design, not just one screen
+- **conviction** — committing to a global maximum instead of iterating toward a local one
+
+---
+
+## raising the floor vs raising the ceiling
+
+AI is best used to **raise the floor** — automate the mechanical 80% (layout scaffolding, responsive grids, state matrices, boilerplate). this frees human attention for **raising the ceiling** — the last 10-20% that requires taste, instinct, and conviction.
+
+don't use AI to make the final call. use it to clear the drudgery so you can spend your time on the part that matters: the unique spin, the unexpected choice, the thing a model would never pick on its own.
+
+**cognitive delegation, not cognitive surrender.** AI routes you to the destination (like Google Maps). you keep the viewpoint and make the final decision. accepting an 8-page AI plan without reading it is cognitive surrender — that's how everything starts looking the same.
+
+---
+
 ## typography
 
 **avoid:** inter, roboto, open sans, lato, arial, montserrat, system defaults. also avoid monospace as lazy shorthand for "technical/developer" vibes.
@@ -342,9 +368,54 @@ the fingerprints of AI-generated work:
 - sparklines as decoration
 - rounded rectangles with drop shadows
 - large icons with rounded corners above headings
+- **"claude beige"** — the generic off-white/off-gray background every AI site defaults to
+- **instrument serif** overuse — the italicized serif headline that now signals "AI-generated" the way inter once did
+- **generic tinted backgrounds** — flat color-tinted sections with no texture, depth, or intention
 
 a distinctive interface should make someone ask "how was this made?" not "which AI made this?"
 
+### anti-attractors
+
+models have attractor states — defaults they fall into because training data is weighted toward them. purple gradients, instrument serif, "claude beige" — these are gravity wells. to escape them you need **anti-attractors**: deliberate constraints that force the model off its well-trodden path.
+
+techniques:
+- **name the thing you don't want** — "no purple, no serif headline, no off-white background" closes the attractor
+- **seed with a reference** — point at a specific site, era, or designer's work as the target aesthetic
+- **inject a constraint** — "monochrome only," "no rounded corners," "one font weight" — scarcity forces creativity
+- **rotate your defaults** — if your last three projects used dark mode, force light. if they used sans, force serif. the convergence trap is real.
+
+---
+
+## ax — agentic experience
+
+UX is design for humans. **AX is design for AI agents** that are becoming primary users of software. when an agent interacts with your CLI, API, or surface, visual affordances don't help — it can't see your button. what it needs:
+
+- **speed** — fast responses, low latency, no unnecessary round trips
+- **clarity** — unambiguous output, structured data, predictable shapes
+- **verbosity where needed** — error messages that tell the agent what to do next, not just what failed
+- **edge case coverage** — agents will hit paths humans never touch; handle them explicitly
+- **agentic affordances** — `llms.txt`, `robots.txt`, clear `--help`, machine-readable status, stable exit codes
+
+AX is not optional anymore. if your tool is agent-facing, design the agent's experience as deliberately as the human's.
+
+---
+
+## conviction over local maxima
+
+good design is a bet. iterating toward "slightly better" produces a **local maximum** — safe, defensible, forgettable. great design requires **conviction**: choosing a global maximum that might look wrong at first but is a superior endpoint.
+
+the engineer's instinct is to optimize incrementally. the designer's job is to make a bet and commit. AI accelerates iteration, which makes the local-maximum trap *worse* — you can now converge on average faster than ever.
+
+**subtraction over addition.** the strongest design move is often removing something. steve jobs as editor, not steve jobs as builder. when a screen feels cluttered, don't add structure — delete until it breathes.
+
+---
+
+## the scarcity principle
+
+taste emerges from constraints. the european and japanese craft traditions produced distinctive work because materials were scarce — you had to choose carefully. in an era of infinite digital materials (every color, every font, every layout is free), taste must be **intentionally cultivated through self-imposed scarcity**.
+
+pick constraints before you start: one font, two colors, three spacing values. scarcity forces decisions. infinite options produce the distribution center.
+
 ---
 
 ## references

package/atris/policies/design-seed.md

@@ -0,0 +1,187 @@
+# design-seed.md — atris visual identity
+
+> Generated from a design interview on 2026-06-23.
+> This is the project's unique design DNA. Not a template — a conviction.
+> Every design decision for Atris surfaces should reference this seed.
+
+---
+
+## the interview (source signal)
+
+| question | answer |
+|----------|--------|
+| audience | designers, product enthusiasts, apple lovers, artsy people |
+| anti-attractor | AI startup slop — purple gradients, claude beige, instrument serif |
+| personality | warm-technical — sharp but human, approachable craft |
+| color mood | warm earth — clay, bone, ink, ochre |
+
+**the move:** this is not a dev tool that needs to look "technical." this is a crafted object that happens to be powerful. the bar is set by people who notice the kerning on a restaurant menu.
+
+---
+
+## typography
+
+**display: Spectral**
+- warm serif designed for screens (Production Type)
+- intellectual without being precious
+- has optical sizing — gets more expressive at large sizes
+- NOT instrument serif (the AI tell), NOT Fraunces (getting there), NOT Playfair (overused)
+- weights: 200 (light, for quiet headlines) and 700 (for bold statements)
+- italic available — use sparingly, for emphasis only
+
+**body: Hanken Grotesk**
+- humanist sans with warmth and character
+- not inter, not roboto, not system — has a hand to it
+- weights: 400 (body), 600 (emphasis)
+- slightly more readable than geometric sans at small sizes
+
+**mono: JetBrains Mono**
+- for code, CLI output, technical labels only
+- never as a "developer vibe" design choice
+
+**type scale (fluid):**
+```css
+--font-display: 'Spectral', Georgia, serif;
+--font-body: 'Hanken Grotesk', system-ui, sans-serif;
+--font-mono: 'JetBrains Mono', monospace;
+
+--text-xs: 0.75rem;
+--text-sm: 0.875rem;
+--text-base: 1rem;
+--text-lg: clamp(1.25rem, 1rem + 1vw, 1.5rem);
+--text-xl: clamp(1.75rem, 1rem + 3vw, 2.5rem);
+--text-display: clamp(2.5rem, 1rem + 6vw, 5rem);
+```
+
+**rules:**
+- display font for headlines only. body stays in Hanken.
+- weight extremes: 200 vs 700, never 400 vs 500.
+- size jumps are dramatic (3x), not timid.
+- line-height: 1.6 for body (generous, warm). 1.1 for display (tight, confident).
+- max-width: 62ch for long-form. let it breathe.
+
+---
+
+## color
+
+warm earth palette. everything tinted warm. no pure gray, no pure black, no pure white.
+
+```css
+:root {
+  /* surfaces */
+  --bone:     oklch(96% 0.012 75);   /* warm paper — the base */
+  --bone-2:   oklch(93% 0.014 72);   /* slightly deeper, for sections */
+  --ink:      oklch(22% 0.015 55);   /* warm near-black — primary text */
+  --ink-soft: oklch(35% 0.012 55);   /* secondary text, still warm */
+  --ink-faint:oklch(55% 0.010 60);   /* tertiary, metadata */
+
+  /* accents — used rarely, earn their place */
+  --clay:     oklch(58% 0.13 45);    /* terracotta — the sharp accent */
+  --ochre:    oklch(72% 0.09 75);    /* warm gold — for highlights */
+  --moss:     oklch(42% 0.04 145);   /* deep muted green — secondary accent */
+
+  /* depth */
+  --shadow:   oklch(15% 0.01 55);    /* deepest warm dark */
+  --line:     oklch(88% 0.010 70);   /* warm hairline borders */
+}
+```
+
+**usage rules:**
+- `--bone` is the default background. never `#fff`. never `#f5f5f5`.
+- `--ink` is the default text. never `#000`. never `#1a1a1a`.
+- `--clay` is the one sharp accent. use it for one thing per view — a link, a CTA, a key number. if you use it for three things, it's not an accent anymore.
+- `--ochre` for subtle highlights (selection, hover warmth). never for text.
+- `--moss` appears rarely — maybe a status indicator, a secondary chart. it's the surprise.
+- never put `--ink-faint` text on `--clay` backgrounds. use `--bone` on `--clay`.
+- dark mode: invert to warm dark (`oklch(18% 0.015 55)` background, `--bone` text). never zinc, never pure dark.
+
+---
+
+## spacing
+
+warm-technical means generous but not wasteful. more space than feels comfortable, then a little more.
+
+```css
+--space-xs:  0.5rem;
+--space-sm:  1rem;
+--space-md:  2rem;
+--space-lg:  4rem;
+--space-xl:  8rem;    /* section gaps — dramatic */
+--space-2xl: 12rem;   /* used sparingly, for major breaks */
+```
+
+**rhythm:** vertical spacing locked to `--space-md` (2rem) as the base unit. section gaps are `--space-xl` (8rem). this creates a 1:4 ratio between content rhythm and section breaks — you feel the structure without seeing it.
+
+---
+
+## layout
+
+**editorial, not templated.**
+
+- no hero + 3 cards + footer. ever.
+- asymmetric layouts. left-aligned with intentional negative space on the right.
+- wide margins (clamp(1.5rem, 8vw, 8rem)) — content sits in the center 60-70% of the viewport.
+- sections separated by `--space-xl` (8rem) of pure `--bone`. the space IS the design.
+- no cards unless content genuinely needs a container. most things sit directly on `--bone`.
+- if you must group, use `--bone-2` (slightly deeper) with no border, or a single `--line` hairline.
+
+**the page should feel like a well-set book page, not a dashboard.**
+
+---
+
+## motion
+
+warm-technical = things take their time, but nothing wastes it.
+
+```css
+--ease: cubic-bezier(0.25, 1, 0.5, 1);   /* exponential ease-out */
+--dur-fast: 200ms;
+--dur-base: 350ms;    /* slightly slower than default — warm */
+--dur-slow: 600ms;    /* for page reveals */
+```
+
+- one reveal animation on page load: staggered fade-up, 80ms between elements, `--dur-slow`.
+- hover: subtle warm brighten (filter: brightness(1.05)) + scale 1.02. never shift, never hide.
+- no cursor effects. no meteor showers. no parallax.
+- `prefers-reduced-motion`: everything instant. the static version must be beautiful on its own.
+
+---
+
+## the anti-attractor lock
+
+these are banned for Atris surfaces, derived from the interview:
+
+| banned | why |
+|--------|-----|
+| purple-to-blue gradients | AI slop fingerprint #1 |
+| off-white / `#fafafa` backgrounds | "claude beige" — the new AI default |
+| instrument serif (italic) | the new AI tell — everyone uses it |
+| inter / roboto / system fonts | statistically average, aesthetically dead |
+| glassmorphism | decorative blur = no point of view |
+| dark mode with neon accents | "cool" without a design decision |
+| hero + 3 cards + footer | the template. every AI does this. |
+| gradient text on headlines | looks impressive, means nothing |
+| rounded-rect with drop shadow | safe, forgettable, templated |
+| all-caps tracked labels | keshav hates it. not warm. |
+
+---
+
+## the conviction
+
+this design says: **we care about the thing you're looking at, not the fact that we made it.**
+
+it's warm paper, warm ink, one sharp terracotta accent, a serif that has opinions, and enough negative space that you notice the content. it doesn't shout. it doesn't perform. it's made well, and you can feel that before you can name it.
+
+if a designer looks at this and thinks "AI made this," we failed.
+if they think "someone made this," we're on track.
+if they think "who made this?" — that's the goal.
+
+---
+
+## references (inspiration, not copies)
+
+- Aesop.com — warm earth, editorial, restraint
+- Apple product pages — typography confidence, negative space
+- Linear changelog — warm-technical writing in a UI
+- Istituto Marangoni — editorial layout, Italian craft
+- a well-printed paperback — the feeling we're chasing

package/atris/skills/atris/SKILL.md

@@ -31,12 +31,35 @@ Key behaviors:
 - Read PERSONA.md (3-4 sentences, ASCII visuals)
 - Check MAP.md for file:line refs
 - Use `atris task` for claims, proof, ready, and accept
+- Use functional/feature members as task owners; record engines only as `executed_by`
 - Treat TODO.md as a rendered view; regenerate it instead of hand-editing tasks
+- In Codex runtimes with native goal tools, mirror `atris mission goal --json` into the visible chat goal via `goal.visible_goal`
+
+## Visible Chat Goal Mirror
+
+Before choosing work in an Atris repo, run:
+
+```bash
+atris mission goal --json
+```
+
+If it returns `action: codex_goal_candidate` or `codex_goal_heartbeat` with
+`goal.visible_goal`, treat that as the desired native chat goal:
+
+1. Call `get_goal` when the runtime exposes it.
+2. If the active goal already equals `goal.objective`, keep working.
+3. If there is no active goal or the prior goal is complete, call `create_goal` with `goal.objective`.
+4. If a different active goal is still in progress, do not complete it just to make room; report that `goal.visible_goal.status` is waiting for the visible goal slot.
+5. After proof is ready, call `update_goal({ status: "complete" })`, rerun `atris mission goal --json`, then create the next visible goal candidate when a slot is available.
+
+Native goal completion is not task acceptance. Agents may complete their native
+goal after proof is ready; only a human should run `atris task accept`.
 
 ## Steps
 
 1. Run `atris atris.md` on first interaction to show workspace status
 2. Read `atris/MAP.md` before any file search to find file:line refs
-3. Run `atris task list` or `atris task next` to find current work
-4. Claim tasks with `atris task claim <id> --as <agent>`
-5. Move completed work to review with `atris task ready <id> --proof "..."`
+3. Run `atris mission goal --json` and mirror `goal.visible_goal` into the native chat goal when the runtime supports it
+4. Run `atris task list` or `atris task next` to find current work
+5. Claim tasks with `atris task claim <id> --as <functional-member>`
+6. Move completed work to review with `atris task ready <id> --proof "..."`

package/atris/skills/design/SKILL.md

@@ -16,8 +16,9 @@ Part of the Atris policy system. Prevents ai-generated frontend from looking gen
 
 This skill uses the Atris workflow:
 1. Check `atris/MAP.md` for existing patterns before building
-2. Reference `atris/policies/atris-design.md` for full guidance
-3. After building, run `atris review` to validate against this policy
+2. **Read `atris/policies/design-seed.md` first** — it has the project's unique visual identity (fonts, colors, spacing, motion). This is the design DNA. Do not override it with defaults.
+3. Reference `atris/policies/atris-design.md` for full anti-slop guidance
+4. After building, run `atris review` to validate against this policy
 
 ## Quick Reference
 

package/atris/skills/loop/SKILL.md

@@ -30,7 +30,7 @@ The agent then:
    - `cron`: `"*/13 * * * *"` (every 13 min) for tight loops, or `"7 * * * *"` (hourly at :07) for slow loops
    - `prompt`: `"First run: atris mission run --due --max-ticks 1 --complete-on-pass. If it reports no_due_mission, run /autopilot for one tick. One bounded goal only, then stop. Do not start a conversation."`
    - `recurring`: `true`
-   - `durable`: `false` (in-memory only — gone when this Claude session ends)
+   - `durable`: `false` (in-memory only, gone when this Claude session ends)
 2. After creating, calls `CronList` and shows the user the active cron jobs.
 3. Tells the user: "loop is alive. job id <X>. fires roughly every <N> minutes. say 'stop the loop' to kill it. auto-expires after 7 days."
 
@@ -68,6 +68,8 @@ If the user says "kill all loops", call `CronList`, then `CronDelete` for every
 
 This is the autonomous mode. Without `/loop`, `/autopilot` only runs when a human invokes it.
 
-## Wiki upkeep is a separate concern
+## The CLI front door and wiki upkeep
 
-The CLI command `atris loop` is wiki upkeep (stale pages, orphans, ingest candidates). That's a different verb on the same name. If the user wants wiki health, run `atris loop` from a terminal. If they want the autopilot heartbeat, invoke `/loop` here in Claude Code.
+The CLI command `atris loop` is now the single front door to the self-improvement loop: `atris loop start` (local), `atris loop start --overnight` (durable heartbeat), `atris loop status`, `atris loop stop`. It delegates to the existing engines (`run`, `pulse`) rather than adding a new one.
+
+Wiki upkeep (stale pages, orphans, ingest candidates) moved to `atris loop wiki` (or `atris wiki loop`). If the user wants wiki health, run that. If they want the autopilot heartbeat from inside Claude Code, invoke `/loop` here.

package/atris/team/_template/MEMBER.md

@@ -8,6 +8,9 @@ skills: []
 
 permissions:
   can-read: true
+  can-execute: true
+  can-approve: false
+  can-accept-task: false
   approval-required: []
 
 tools: []
@@ -21,6 +24,16 @@ Replace with the long-term mission this member owns.
 
 Replace with what this member may and may not touch.
 
+## Cadence
+
+Replace with how often this member may wake up, how long one tick may run, and the lease timeout.
+
+## Ownership Contract
+
+- Own tasks by function or feature, never by execution engine.
+- If no existing member fits, create a member-creation task before assigning broad work.
+- Put coding agent models like Codex and Claude in the `executed_by` section.
+
 ## Proof Standard
 
 Replace with what proves good work.
@@ -29,6 +42,12 @@ Replace with what proves good work.
 
 Replace with when this member must stop and ask.
 
+## Cleanup Contract
+
+- Use isolated worktrees for parallel work.
+- Ship or archive the worktree before the lease ends.
+- Move proof-backed work to Review; never run human accept.
+
 ## Log System
 
 Every member keeps a dated log under `logs/YYYY-MM-DD.md`.

package/atris.md

@@ -10,9 +10,10 @@ leave a trail another agent or human can trust.
 On session start, before responding:
 
 1. Read:
-   - `atris/logs/YYYY/YYYY-MM-DD.md` — today's journal
-   - `atris/MAP.md` — navigation
-   - `atris/wiki/STATUS.md` if present — current memory snapshot
+   - `atris/logs/YYYY/YYYY-MM-DD.md`: today's journal
+   - `atris/MAP.md`: navigation
+   - `atris/CLARITY.md` if present: how the operator works (voice, cadence, leash); prompt yourself to match it
+   - `atris/wiki/STATUS.md` if present: current memory snapshot
 
 2. Show this box, then ask what to work on if no task was already given.
 
@@ -50,13 +51,36 @@ Then:
 - do not call something complete without verification
 - do not take irreversible actions without approval from the human
 - do not hide state outside markdown, logs, diffs, or the journal
-- do not edit the rules that judge you — the reward config, the authority policy, or this file
+- do not edit the rules that judge you: the reward config, the authority policy, or this file
 
 If you cannot honor these rules, stop, write why in the journal, and ask the human before continuing.
 
 Labels used below:
-- `guarded` — checked by code or a pre-commit hook; bypassing is a bug
-- `expected` — convention; honor it or stop
+- `guarded`: checked by code or a pre-commit hook; bypassing is a bug
+- `expected`: convention; honor it or stop
+
+## taste
+
+What you ship should not read as generated. The test: if someone said "an AI made this," would they believe it instantly? If yes, that is the bug. The model has no words for restraint and it falls into gravity wells. Beat both.
+
+- **Gate it.** `atris slop detect <path>` is deterministic: no model, exit 1 on a tell, built for CI and the review stage. A finding is a fact (file:line + rule), not an opinion. `guarded` once wired into review.
+- **Name the move.** Vague prompts make vague output. Direct with craft words: vertical rhythm, negative space, hierarchy, contrast, bolder here / quieter there, restraint. Precise language is the lever. Own it.
+- **Refuse the wells** (named so you can): purple/indigo gradients, gradient-filled text, glassmorphism, Inter/Roboto defaults, claude-beige, neon-on-dark, hero-metric rows, identical card grids, eyebrow/tracked-caps labels, pulsing live-dots, em dashes.
+- **Commit to constraints.** One distinctive font, one accent hue, a small spacing scale. Taste is subtraction, not addition.
+- **Generate it right.** `atris deck` (slides) and the `design` policy apply the system by default: own backgrounds and fonts, never the tool's stock template.
+- **Compound it.** A new tell becomes a typed lesson with a `detector:` regex, so the gate grows instead of leaning on memory. Taste lives in code, not vibes.
+
+## voice
+
+The same discipline for words. Output stays sharp no matter how bloated the context. A full context is not license to ramble.
+
+- **Lead with the move.** Answer first, support after. No preamble, no agreement reflex ("great question", "you're absolutely right").
+- **Specific over buzzy.** Name the exact thing. If you can't, you don't understand it yet; go look, don't hedge.
+- **Cut filler.** Drop "it's worth noting", "in order to", "leverage", "seamless", "robust", "delve", stacked hedges, and em dashes. `atris slop` flags the prose tells (em-dash, hype-copy) too.
+- **Bound verbosity by information, not context.** Say the load-bearing thing and stop. Length tracks what the reader needs to act, nothing more.
+- **Match the register.** The operator wants the next move; a spec wants the contract; a journal wants one line. Jargon is a lever only when shared: use the reader's precise terms, define a new one once.
+
+`expected`: this is how an Atris agent writes and builds. Shipping slop or rambling is a failure smell, same as drift or a stale task.
 
 ## task source of truth
 
@@ -70,11 +94,11 @@ Core loop:
 
 ```bash
 atris task list
-atris task delegate "<title>" --to <owner> --tag <tag>
-atris task delegate "<title>" --to <owner> --via swarlo --tag <tag>
+atris task delegate "<title>" --to <functional-member> --tag <tag>
+atris task delegate "<title>" --to <functional-member> --executed-by <engine> --via swarlo --tag <tag>
 atris task day
 atris task next
-atris task claim <id> --as <agent>
+atris task claim <id> --as <functional-member>
 atris task note <id> "<context, blocker, decision, or handoff>"
 atris task finish <id> --proof "<tests, screenshot, diff, or receipt>"
 atris task review <id> --lesson "<what improved>" --next "<next task>"
@@ -89,7 +113,7 @@ Every task record should carry:
 
 ```
 Title: <small work packet>
-Owner: <agent or unclaimed>
+Owner: <functional or feature member, not an engine>
 Objective: <why this matters>
 Context: <links/files/decisions>
 Exit: <observable done condition>
@@ -97,6 +121,21 @@ Verify: <shell command or concrete proof>
 Next: <suggested follow-up task>
 ```
 
+Task planning preview and landing:
+
+```
+Owner: <functional-member>
+Plan: <one sentence on the intended change>
+Done: <observable result>
+Check: <verifier, receipt, or artifact proof>
+```
+
+Owner is accountable company role (`task-planner`, `architect`, `mission-lead`,
+`validator`, `launcher`, or a feature owner). Coding agent models like Codex and
+Claude are not task owners; put them in the `executed_by` section when useful.
+If no existing member fits, create a member-creation task instead of assigning
+broad work to an engine or generic executor.
+
 | Field | Meaning | Enforcement |
 |---|---|---|
 | tier | `agent` proceeds, `gray` queues for approval, `human` never attempted by you | guarded |
@@ -121,10 +160,10 @@ The human is the constructor. You multiply. Handoff fidelity lives in the files,
 
 Move one task at a time through plan → do → review.
 
-- **plan** — read relevant files, produce an ASCII visualization, wait for approval. No code.
-- **plan-review** — the validator reads the plan fresh and signs off with `SIGNOFF:` or halts with `REJECT:` + `FIX:` + an optional `PROPOSED:` block (concrete draft of Files / Exit / Verify / Rollback to replace). Plan does not move to do without signoff. The validator is a drafting partner, not just a critic — on REJECT it proposes the sharper rubric rather than leaving the human to guess. Codex is optional escalation when `ATRIS_USE_CODEX=1` or the task carries `[codex]`.
-- **do** — claim the task with `atris task claim <id> --as <agent>`, execute step by step, add notes as reality changes, update `MAP.md` and the journal when needed.
-- **review** — run the task's verification, read the diff, run the relevant tests, finish with `atris task finish <id> --proof "..."`, and add the lesson/next task with `atris task review`.
+- **plan**: read relevant files, produce an ASCII visualization, wait for approval. No code.
+- **plan-review**: the validator reads the plan fresh and signs off with `SIGNOFF:` or halts with `REJECT:` + `FIX:` + an optional `PROPOSED:` block (concrete draft of Files / Exit / Verify / Rollback to replace). Plan does not move to do without signoff. The validator is a drafting partner, not just a critic: on REJECT it proposes the sharper rubric rather than leaving the human to guess. Codex is optional escalation when `ATRIS_USE_CODEX=1` or the task carries `[codex]`.
+- **do**: claim the task with `atris task claim <id> --as <agent>`, execute step by step, add notes as reality changes, update `MAP.md` and the journal when needed.
+- **review**: run the task's verification, read the diff, run the relevant tests, finish with `atris task finish <id> --proof "..."`, and add the lesson/next task with `atris task review`.
 
 Every stage runs the Confidence Gate before it advances:
 
@@ -177,7 +216,7 @@ Periodically, and before closing an endgame, clean:
 - **I1:** Description
 
 ## Notes
-[timestamped lines — one per discovery, decision, or tick]
+[timestamped lines: one per discovery, decision, or tick]
 ```
 
 Context is a cache. Disk is truth. Route discoveries as they happen:
@@ -195,12 +234,13 @@ Do not batch. Nothing important should live only in memory.
 
 ## failure smells
 
-If you notice these, stop and flag — do not continue:
-- **loop** — the same suggestion fires tick after tick, nothing changes on disk
-- **drift** — `MAP.md` file:line refs no longer match the code
-- **stale task** — a backlog task references a file or symbol that no longer exists
-- **hidden side effect** — an action changed external state (email sent, money moved, deploy) without a queued approval
-- **unverifiable completion** — a task marked complete without a `Verify:` command that actually ran
+If you notice these, stop and flag, do not continue:
+- **loop**: the same suggestion fires tick after tick, nothing changes on disk
+- **drift**: `MAP.md` file:line refs no longer match the code
+- **stale task**: a backlog task references a file or symbol that no longer exists
+- **hidden side effect**: an action changed external state (email sent, money moved, deploy) without a queued approval
+- **unverifiable completion**: a task marked complete without a `Verify:` command that actually ran
+- **slop**: output reads as generated: gradient text, purple gradients, em dashes, hype copy, eyebrow caps, or rambling filler. `atris slop detect` names it; fix it before shipping (see `## taste` and `## voice`)
 
 Each has real examples in `lessons.md`. Before nontrivial execution, read the relevant recent lessons.
 
@@ -217,10 +257,10 @@ Pages that summarize or reference other files declare their sources in YAML fron
 
 If any source was modified after `last_compiled`, the page is stale. Re-read the sources, update the page, bump `last_compiled`.
 
-Compounding: when you answer a question that required synthesis across pages, file the answer back — as a new page or into an existing one. Explorations accumulate.
+Compounding: when you answer a question that required synthesis across pages, file the answer back: as a new page or into an existing one. Explorations accumulate.
 
 Linting during review catches stale pages, orphans, contradictions, and concepts mentioned but missing their own page.
 
 ---
 
-*Canonical copy: workspace root `atris.md`. Project copies are distributed; `atris update` syncs them. Full spec: `atrisDev.md`.*
+*Canonical copy: workspace root `atris.md`. Project copies are distributed; `atris update` syncs them.*