atris 3.16.1 → 3.22.0

package/README.md

@@ -185,10 +185,21 @@ atris business record atris/reports/2026-04-12-operator-recap.md --outcome mixed
 | `atris do` | Execute work |
 | `atris review` | Validate work and capture learnings |
 | `atris run` | Auto-chain `plan -> do -> review` |
+| `atris run logs` | Browse glass run logs (phase reasoning persisted to disk) |
+| `atris run prune-logs` | Prune old run logs, keeping only the most recent N |
+| `atris run search` | Search phase reasoning across all run logs by keyword |
+| `atris run stats` | Show run log stats: phase counts, avg durations |
+| `atris run export` | Export all run logs as a JSON bundle |
+| `atris run diff` | Compare two run logs side by side |
 | `atris autopilot` | Guided loop with approvals |
+| `atris pulse` | Install or run the durable overnight heartbeat |
 | `atris log` | Add inbox items to today's journal |
+| `atris now` | Show the current operating truth |
+| `atris radar` | Show live agents joined with tasks, missions, and worktrees |
+| `atris ctop` | Show process-first live agent CPU and memory |
 | `atris status` | Show active work and completions |
 | `atris task` | Durable local task state and the agent work loop |
+| `atris mission` | Durable goal, owner, verifier, tick receipts, and loop state |
 | `atris play` | Enter the AgentXP player loop for one proof-backed mission |
 | `atris gm` | Enter AgentXP General Manager mode for player missions and review queues |
 | `atris xp` | Show the local AgentXP card and sync eligible proof to the hosted leaderboard |
@@ -200,6 +211,7 @@ atris business record atris/reports/2026-04-12-operator-recap.md --outcome mixed
 | `atris receipt` | Save evidence from an agent run |
 | `atris experiments` | Run small experiments and compare results |
 | `atris computer card` | Show or write the local owner/computer card |
+| `atris release` | Draft or publish a version bump, tag, GitHub release, and launch post |
 
 ## Built-In Systems
 
@@ -211,7 +223,9 @@ atris business record atris/reports/2026-04-12-operator-recap.md --outcome mixed
 - `atris activate` loads the current wiki status so the next session starts with project memory, not just tasks
 - `atris member` keeps team-member identity and learning local-first: `MEMBER.md` is the role contract, `goals.json` is the machine-readable goal/experiment state, `goals.md` is the human readout, and `logs/YYYY-MM-DD.md` records what happened. Use `atris member goal`, `tick`, `status`, `block`, and `review --value 1..5` to test whether a member is making useful progress or needs the operator/orchestrator.
 - `atris codex-goal` is the guarded bridge for native Codex `/goal`: `status` reads `~/.codex/state_5.sqlite`, while `reset --thread <id> --confirm-complete-goal-reset` backs up the DB, dumps the exact completed `thread_goals` row, deletes only that completed row, and writes a receipt. The next native goal must still be created by the live Codex thread; Atris Mission/member goals remain the durable loop state.
-- `atris task` keeps durable local task state and append-only events for agents; `atris/TODO.md` is just a regenerated readable board. Run the loop with `atris task new`, `delegate "..." --to <owner>`, `next`, `say`, and `ready <id> --proof "..."`; human approval is `atris task accept <id>` (moves to Done, awards Career XP) or `revise <id> --note "..."`. Add `--json` for headless agents, `atris task serve` for the local board, and `atris task show <ref>` / `events --all` for the full ledger. Commands accept semantic refs (`OBL-18`), full IDs, or any unique prefix. In cloud business workspaces, Supabase `tasks` is the source of truth and Swarlo the live claim layer.
+- `atris task` keeps durable local task state and append-only events for agents; `atris/TODO.md` is just a regenerated readable board. Run the loop with `atris task new`, `delegate "..." --to <owner>`, `next`, `say`, and `ready <id> --proof "..."`; human approval is `atris task accept <id>` (moves to Done, awards Career XP) or `revise <id> --note "..."`. Final task transitions also append the general daily log and, when a real `atris/team/<member>/MEMBER.md` matches the task owner, that member's daily log. Add `--json` for headless agents, `atris task serve` for the local board, and `atris task show <ref>` / `events --all` for the full ledger. Commands accept semantic refs (`OBL-18`), full IDs, or any unique prefix. In cloud business workspaces, Supabase `tasks` is the source of truth and Swarlo the live claim layer.
+- `atris mission` is the durable autonomy layer: start with an owner, verifier, runner, and stop condition; record bounded work with `mission tick`; close with `mission complete` only after proof. Runners include `manual`, `claude`, `atris2`, and `codex_goal`.
+- `atris pulse` is the OS-cron heartbeat for overnight self-improvement. Use `atris pulse status`, `tick`, `run`, `install --cadence "<cron>" --days 7 --verify "npm test" --model opus`, and `uninstall`.
 - `atris experiments` runs small test packs in `atris/experiments/`
 - `atris pull` and `atris push` sync cloud workspaces and journals
 - `atris live` keeps a business brain fresh by checking/fixing the workspace, pushing local state, pulling cloud state, and pushing again after local changes go quiet
@@ -279,13 +293,24 @@ atris skill link [--all]
 
 For Codex, copy any skill folder into `~/.codex/skills/`.
 
-## Recent changes
+## Before a New Version
 
-- **Staleness gate** — tasks tagged `[unverified]` are skipped at the moment of use, not pruned eagerly. Three-state model: actionable / unverified / deleted.
-- **Lesson gate** — `isLessonResolved` checks whether a lesson already shipped before proposing new work from it. Prevents the loop from re-solving solved problems.
-- **`atris release`** — new command: tags the version, bumps package.json, creates a GitHub release, and drafts a `/launch` post in one shot.
-- **Shell injection fix** — `checkStaleness` switched from `execSync` string interpolation to `execFileSync` with args arrays. Markdown-derived content (task titles, inbox items) no longer reaches a shell.
-- **Codex hardening** — `atris activate` and `atris` entry point detect Codex environments and write `AGENTS.md` so Codex sessions start with workspace context.
+Run the release-facing checks before bumping:
+
+```bash
+node bin/atris.js --help
+node bin/atris.js pulse --help
+node bin/atris.js release --help
+node --test
+```
+
+Then dry-run the release:
+
+```bash
+atris release --dry-run
+```
+
+`atris release` drafts or publishes from local git history. `--dry-run` prints the planned bump without committing, tagging, or pushing.
 
 ## Update
 

package/atris/skills/atris/SKILL.md

@@ -1,6 +1,11 @@
 ---
 name: atris
-description: Atris workspace navigation for atris repos, TODO files, tasks, MAP.md, backlog, and where-is-X questions.
+description: "Atris workspace navigation for atris repos, TODO files, tasks, MAP.md, backlog, and where-is-X questions. Use when navigating an Atris workspace, finding files via MAP.md, or checking task state."
+version: 1.0.0
+tags:
+  - atris
+  - navigation
+  - workspace
 allowed-tools: Read, Bash, Glob, Grep, Write, Edit
 ---
 
@@ -26,4 +31,12 @@ 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
-- Treat TODO.md as a rendered view; regenerate it instead of hand-editing tasks
+- Treat TODO.md as a rendered view; regenerate it instead of hand-editing tasks
+
+## 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 "..."`

package/atris/skills/atris-feedback/SKILL.md

@@ -12,6 +12,13 @@ tags:
 
 One skill for everything: submit feedback, view the queue, resolve/close/delete items.
 
+## Steps
+
+1. Parse the user input to determine the feedback action (list, submit, resolve, close, delete)
+2. Run the matching `atris feedback` CLI command from the reference below
+3. If `atris` CLI is unavailable, fall back to the direct API/DynamoDB path
+4. Report the result to the user
+
 ## Parse the input
 
 - `/feedback` (no args) → show the queue

package/atris/skills/design/SKILL.md

@@ -56,13 +56,37 @@ Font alternatives: instead of Inter → Instrument Sans, Plus Jakarta Sans, Outf
 
 **Labels:** never use all-caps UI labels, tracked-uppercase labels, faux small-caps, or eyebrow-style microcopy for ordinary product surfaces. Keshav strongly dislikes this style. Prefer natural title case or sentence case for labels like "Threads", "Active tasks", and "Team"; do not write them as `THREADS`, `ACTIVE TASKS`, or letter-spaced metadata.
 
-**Visual anti-patterns:** no glassmorphism, no gradient text, no sparklines as decoration, no rounded-rect-with-colored-border, no large icons with rounded corners above headings, no hero metric layout (big number + small label), no modals unless truly necessary.
+**Visual anti-patterns:** no glassmorphism, no gradient text, no sparklines as decoration, no rounded-rect-with-colored-border, no large icons with rounded corners above headings, no hero metric layout (big number + small label), no modals unless truly necessary. no "claude beige" off-white backgrounds, no instrument serif overuse (the new AI tell), no generic flat tinted backgrounds.
+
+## Vocabulary is the Lever
+
+Designers beat engineers at AI prompting because they own craft language. Name the move precisely: "tighten vertical rhythm," "increase negative space," "make hierarchy bolder here, quieter there." Vague prompts = vague output. Core terms: vertical rhythm, negative space, bolder/quieter, affordances, meta-design, conviction.
+
+## Raising Floor vs Ceiling
+
+Use AI to raise the floor (automate the mechanical 80% — scaffolding, grids, state matrices). Spend human attention on the ceiling (last 10-20% — taste, instinct, the unexpected choice). Cognitive delegation, not surrender. AI routes you there; you make the final call.
+
+## AX — Agentic Experience
+
+Design for AI agents as users, not just humans. Agents can't see your buttons. They need: speed, clarity, structured output, verbose errors with next steps, edge case coverage, agentic affordances (`llms.txt`, clear `--help`, stable exit codes).
+
+## Conviction Over Local Maxima
+
+Iterating toward "slightly better" = local maximum (safe, forgettable). Great design is a bet on a global maximum. AI makes the local-max trap worse — you converge on average faster. Subtraction over addition: the strongest move is often deleting something.
+
+## Anti-Attractors
+
+Models have gravity wells (purple gradients, instrument serif, claude beige). Escape them deliberately: name what you don't want, seed with a specific reference, inject a constraint (monochrome, one font weight), rotate your defaults between projects.
+
+## The Scarcity Principle
+
+Taste emerges from constraints. Pick constraints before starting: one font, two colors, three spacing values. Infinite options produce the distribution center.
 
 ## The AI Slop Test
 
 > "if you showed this to someone and said 'AI made this,' would they believe you immediately? if yes, that's the problem."
 
-Fingerprints: inter/roboto, purple-to-blue gradients, cyan-on-dark, glassmorphism, gradient text, hero metrics, identical card grids, bounce easing, dark mode with neon, sparklines as decoration, rounded rectangles with drop shadows.
+Fingerprints: inter/roboto, purple-to-blue gradients, cyan-on-dark, glassmorphism, gradient text, hero metrics, identical card grids, bounce easing, dark mode with neon, sparklines as decoration, rounded rectangles with drop shadows, "claude beige" off-white backgrounds, instrument serif overuse, generic flat tinted backgrounds.
 
 ## Before Shipping Checklist
 
@@ -79,6 +103,9 @@ Run through `atris/policies/atris-design.md` "before shipping" section:
 - WCAG AA contrast (4.5:1 text, 3:1 UI)?
 - works on mobile (44px touch targets, no horizontal scroll, readable text)?
 - respects `prefers-reduced-motion`?
+- did you name the moves in craft vocabulary (vertical rhythm, negative space, bolder/quieter)?
+- did you use anti-attractors (named what to avoid, seeded a reference, set a constraint)?
+- if agent-facing: does it have agentic affordances (clear errors, structured output, stable exit codes)?
 - would a designer clock this as ai-generated?
 
 ## Atris Commands

package/atris/skills/engines/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: engines
+description: "Dispatch coding work to an installed terminal agent — Codex, Cursor, or Devin — as an interchangeable worker engine. Claude orchestrates: writes the bounded prompt, the engine builds, Claude verifies and lands. Triggers on: use codex, use cursor, use devin, engine, dispatch to, worker agent, second opinion build."
+version: 1.0.0
+tags:
+  - engines
+  - codex
+  - cursor
+  - devin
+  - orchestration
+---
+
+# Engines — interchangeable terminal workers
+
+One contract, three engines. The orchestrator (you, Claude) writes a bounded task prompt, dispatches it to an engine, then **independently verifies, lands, and pushes** the result. Engines never self-certify.
+
+## Invocation
+
+| Engine | Command | Notes |
+|--------|---------|-------|
+| Codex | `node "${CLAUDE_PLUGIN_ROOT}/scripts/codex-companion.mjs" task --background [--write] "<prompt>"` (via codex plugin / codex:codex-rescue agent) | Poll with `status`, fetch with `result <job-id>` |
+| Cursor | `cursor-agent --trust -p "<prompt>"` (run from the target repo) | Headless print mode; `--trust` required for non-interactive |
+| Devin | `devin -p --permission-mode dangerous -- "<prompt>"` (run from the target repo) | Default permission mode is read-only for writes — build work NEEDS `--permission-mode dangerous`, so only run it in an isolated worktree. Also `devin cloud` for sessions that outlive this machine |
+
+## Picking an engine
+
+- **Codex** — deep root-cause work, long autonomous builds, second-opinion diagnosis. Slowest; runs sandboxed.
+- **Cursor** — fast bounded edits and refactors in a single repo.
+- **Devin** — multi-step feature work; use `cloud` when the run should survive laptop sleep.
+- Parallel builds across repos: one engine job per repo, never two engines writing the same checkout.
+
+## Prompt contract (every dispatch)
+
+1. Name the absolute repo path and tell the engine to `cd` there.
+2. Bound the slice: one task, explicit exit criteria, the verify command to run.
+3. Git rules: `git status` first; stage only own files; never revert others' changes; never destructive git; work on a branch `member/<name>-<slug>` or a worktree.
+4. Require a final report: files changed, verify command + result, branch name.
+
+## Landing (orchestrator duties — never skip)
+
+- **Codex sandbox cannot reach github.com and may get read-only repo access.** Expect temp clones / `git format-patch` fallbacks under `/private/tmp`. Apply patches in a fresh worktree, re-run the verify command yourself, then push.
+- Cursor and Devin run unsandboxed — still re-run the verify command yourself before pushing.
+- Engine task DBs and receipts written inside a sandbox are snapshots; reconcile against the live `atris task` plane after landing.
+- A stalled job (no log output for 30+ min) gets cancelled and taken over; don't wait on it.

package/atris/skills/flow/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: flow
-description: "All-day operating partner. Reads your MEMBER.md, goals, logs, and company state. Tracks work in real time. Updates your identity and goals as you evolve."
+description: "All-day operating partner. Reads your MEMBER.md, goals, logs, and company state. Tracks work in real time. Updates your identity and goals as you evolve. Use when starting a work session, checking member status, or reviewing goals."
 version: 1.0.0
 tags:
   - member

package/atris/skills/wake/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: wake
+description: "Wake a team member by name — use gm [member] or wake up [member] — and run ONE closed-loop tick: boot, inbox, claim, one bounded slice, verify, commit+push, proof, receipt. Optionally dispatch the build to an engine (codex/cursor/devin). Triggers on: gm, good morning, wake up [member], wake the team, run a tick as [member]."
+version: 1.0.0
+tags:
+  - wake
+  - team
+  - members
+  - closed-loop
+  - autonomous-org
+---
+
+# Wake — one tick of a team member
+
+"gm [member]" means: that member does one real unit of work, end to end, with proof. No status theater. If there is nothing real to do, say so and stop.
+
+## Resolving the member
+
+Look for `atris/team/{member}/` (or `team/{member}/`) in the current repo. If the member has a `WAKE.md`, follow it exactly — it overrides this skill. If not, run the default tick below and offer to write a `WAKE.md` from it.
+
+Wake-enabled lanes as of 2026-06-12: `neo` (atrisos-backend), `frontend-core-systems` (atrisos-web), `ios-engineer` (terrace), `mission-lead` (project-obelisk).
+
+## The tick
+
+1. **Boot** — read `MEMBER.md`, `goals.md`, latest log in `logs/`, and `atris/MAP.md`.
+2. **Inbox** — today's log (`atris/logs/{year}/{date}.md`) section `## Feedback inbox`: promote bullets to the plane (`atris task add --tag {product}`), delete promoted bullets.
+3. **Claim** — `atris task queue`; claim the top unclaimed task `--as {member}`. Claimed by someone else → skip, no quick fixes. Nothing unclaimed → find ONE small genuine defect/improvement, add it to the plane, claim that.
+4. **Work** — ONE bounded slice. `git status` first; stage only own files; never destructive git; branch or worktree on shared checkouts. Build-heavy slice? Dispatch to an engine via the `engines` skill — the member still owns verification and the receipt.
+5. **Verify** — run the relevant build/tests. Evidence carries a timestamp.
+6. **Ship** — commit and PUSH to GitHub (at minimum once per completed slice). Then `atris task ready {id} --proof "{evidence}"`.
+7. **Receipt** — one line in today's log. Blocked on a human → `waiting-on-human` task ("WAITING ON {who}: {exact action}"). Nothing to do → say so and end quietly.
+
+## Hard rules
+
+- Only members claim; visiting agents may add/say/delegate, never claim.
+- Human acceptance (`atris task accept*`) is human-only — the CLI enforces it; never spoof agent detection to get past it.
+- One tick per wake. The loop's value is the receipt trail, not the volume.

package/atris/skills/youtube/SKILL.md

@@ -43,15 +43,6 @@ else
   exit 1
 fi
 
-# 4. Auth check
-STATUS=$(curl -s "https://api.atris.ai/api/me" \
-  -H "Authorization: Bearer $TOKEN")
-
-if echo "$STATUS" | grep -q "Token expired\|Not authenticated\|Unauthorized"; then
-  echo "Token expired. Run: atris login --force"
-  exit 1
-fi
-
 echo "Ready. YouTube skill active (5 credits per video)."
 export ATRIS_TOKEN="$TOKEN"
 ```
@@ -70,13 +61,8 @@ TOKEN=$(node -e "console.log(require('$HOME/.atris/credentials.json').token)")
 
 ### Process a Video
 ```bash
-curl -s -X POST "https://api.atris.ai/api/agent/process_youtube" \
-  -H "Authorization: Bearer $TOKEN" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "youtube_url": "https://www.youtube.com/watch?v=VIDEO_ID",
-    "query": "What are the key takeaways?"
-  }'
+atris youtube process "https://www.youtube.com/watch?v=VIDEO_ID" \
+  --query "What are the key takeaways?"
 ```
 
 **Parameters:**
@@ -107,15 +93,10 @@ curl -s -X POST "https://api.atris.ai/api/agent/process_youtube" \
 
 ### Process + Store as Knowledge
 ```bash
-curl -s -X POST "https://api.atris.ai/api/agent/process_youtube" \
-  -H "Authorization: Bearer $TOKEN" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "youtube_url": "https://www.youtube.com/watch?v=...",
-    "query": "Extract the main arguments and evidence",
-    "agent_id": "YOUR_AGENT_ID",
-    "store_as_knowledge": true
-  }'
+atris youtube process "https://www.youtube.com/watch?v=..." \
+  --query "Extract the main arguments and evidence" \
+  --agent "YOUR_AGENT_ID" \
+  --store
 ```
 
 ---
@@ -124,12 +105,12 @@ curl -s -X POST "https://api.atris.ai/api/agent/process_youtube" \
 
 ### "Learn from this YouTube video"
 1. Run bootstrap
-2. Process: `POST /api/agent/process_youtube` with `{youtube_url, query: "What are the key lessons and insights?"}`
+2. Process: `atris youtube process <url> --query "What are the key lessons and insights?"`
 3. Display the analysis to the user
 
 ### "What does this video say about X?"
 1. Run bootstrap
-2. Process with focused query: `{youtube_url, query: "What does this say about X?"}`
+2. Process with focused query: `atris youtube process <url> --query "What does this say about X?"`
 3. Show the focused analysis
 
 ### "Process multiple videos on a topic"
@@ -143,10 +124,7 @@ VIDEOS=(
 
 for url in "${VIDEOS[@]}"; do
   echo "Processing: $url"
-  curl -s -X POST "https://api.atris.ai/api/agent/process_youtube" \
-    -H "Authorization: Bearer $TOKEN" \
-    -H "Content-Type: application/json" \
-    -d "{\"youtube_url\": \"$url\", \"query\": \"Key insights and takeaways\"}"
+  atris youtube process "$url" --query "Key insights and takeaways"
   echo ""
 done
 ```
@@ -154,8 +132,8 @@ done
 
 ### "Save video insights to my agent's memory"
 1. Run bootstrap
-2. Get your agent ID: `curl -s "https://api.atris.ai/api/agent/my-agents" -H "Authorization: Bearer $TOKEN"`
-3. Process with storage: `{youtube_url, agent_id: "...", store_as_knowledge: true}`
+2. Get your agent ID: `atris agent`
+3. Process with storage: `atris youtube process <url> --agent "..." --store`
 4. Agent can now reference these insights in future conversations
 
 ---
@@ -196,12 +174,8 @@ npm install -g atris && atris login
 TOKEN=$(node -e "console.log(require('$HOME/.atris/credentials.json').token)")
 
 # Process a video
-curl -s -X POST "https://api.atris.ai/api/agent/process_youtube" \
-  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
-  -d '{"youtube_url": "https://youtube.com/watch?v=...", "query": "Summarize this"}'
+atris youtube process "https://youtube.com/watch?v=..." --query "Summarize this"
 
 # Process + store to agent knowledge
-curl -s -X POST "https://api.atris.ai/api/agent/process_youtube" \
-  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
-  -d '{"youtube_url": "https://youtube.com/watch?v=...", "agent_id": "YOUR_ID", "store_as_knowledge": true}'
+atris youtube process "https://youtube.com/watch?v=..." --agent "YOUR_ID" --store
 ```

package/atris/team/validator/MEMBER.md

@@ -201,6 +201,7 @@ Status is the scoreboard. One line per version. Anyone can look at validate.md a
 
 ## Rules
 
+0. **Judge never patches** — You detect, verify, certify, revise, and open tasks. You do not edit source files. If a tick finds a fix worth making, open a task for an executor (or quarantine the diff to its own task reviewed by a non-validator actor) — certifying your own patch is the one failure this system cannot absorb.
 1. **Always run tests** — Never approve without green tests
 2. **Update MAP.md** — If files moved or architecture changed
 3. **Update atris/features/README.md** — Add new feature entry with summary, files, keywords

package/atris/wiki/concepts/agent-activation-contract.md

@@ -5,15 +5,15 @@ title: Agent Activation Contract
 sources:
   - atris/CLAUDE.md
   - commands/activate.js
-last_compiled: 2026-06-09
-last_verified: 2026-06-09
+last_compiled: 2026-06-23
+last_verified: 2026-06-23
 confidence: 0.9
 dependencies:
   - atris/wiki/concepts/plan-do-review-loop.md
   - atris/wiki/concepts/wiki-as-memory-substrate.md
 actionability: "Use this before changing agent boot instructions, `atris activate`, MAP-first behavior, first-message requirements, or durable-memory routing."
 created: 2026-05-10
-updated: 2026-06-09
+updated: 2026-06-23
 tags:
   - agent-activation
   - protocol

package/atris/wiki/concepts/workspace-initialization-contract.md

@@ -4,8 +4,8 @@ slug: workspace-initialization-contract
 title: Workspace Initialization Contract
 sources:
   - commands/init.js
-last_compiled: 2026-06-09
-last_verified: 2026-06-09
+last_compiled: 2026-06-23
+last_verified: 2026-06-23
 confidence: 0.86
 dependencies:
   - atris/wiki/systems/atris-cli.md
@@ -13,7 +13,7 @@ dependencies:
   - atris/wiki/concepts/wiki-as-memory-substrate.md
 actionability: "Use this before changing `atris init`, workspace scaffolds, generated agent instructions, project detection, or boot hook behavior."
 created: 2026-05-10
-updated: 2026-06-09
+updated: 2026-06-23
 tags:
   - initialization
   - workspace

package/atris/wiki/index.md

@@ -20,6 +20,7 @@
 - [[atris/wiki/concepts/owner-computer-model.md]] — Owner = User | Business; constrained entity modes, typed computers, and groups as the social/access layer
 - [[atris/wiki/concepts/agent-activation-contract.md]] — editor-facing boot contract: first message, MAP-first, setup, and durable-memory routing
 - [[atris/wiki/concepts/workspace-initialization-contract.md]] — `atris init` bootstrap contract: guards, scaffolds, team context, generated agent files, and hooks
+- [[atris/wiki/concepts/glass-interface-principle.md]] — AI tool design doctrine: make reasoning visible and inspectable, not black-boxed
 
 ## Briefs
 

package/atris.md

@@ -10,9 +10,9 @@ 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/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 +50,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. `--diff`/`--staged` scopes it to changed lines for a commit gate; `--fix` repairs the safe tells. `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), `atris deck from <doc.md> --html` (a web page from a plain doc, in the web app's design tokens), `atris site <dir>` (a whole markdown folder into a navigable site), and `atris recap --html` (a memory-updates page) all apply the system by default: own backgrounds and fonts, never the tool's stock template. Output as an AppBlock with `--block` to drop into a web app.
+- **Compound it.** A new tell becomes a project rule in `.atris/slop.rules.json` (`atris slop rules --add`), and a project's brand lives in `.atris/theme.json` (`atris theme create` builds your own by feel, or `atris theme init` scaffolds one) so every deck, page, and site is on-brand by default. The gate and the look grow per project 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
 
@@ -121,10 +144,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 +200,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 +218,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 +241,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.*