atris 3.15.13 → 3.15.22

package/AGENTS.md

@@ -1,25 +1,66 @@
 # AGENTS.md — Universal Agent Instructions
 
-> Works with: Claude Code, Cursor, Codex, Windsurf, and any AI coding agent.
+> Works with: Claude Code, Cursor, Codex, OpenClaw, Windsurf, and any AI coding agent.
 
 ## Quick Start
 
 ```bash
 atris
+atris task list --status open
+atris task claim <id> --as <agent>
 ```
 
-Run this first. Follow the output.
+Run `atris` first. It prints repo state, the files to read, and the next command.
+
+If there is no existing task, create one before editing:
+
+```bash
+atris task new "<small concrete title>" --tag <area>
+atris task claim <id> --as <agent>
+```
 
 ## Core Files
 
+Atris is the source of truth. This file is only an adapter for tools that read
+`AGENTS.md`; do not turn it into a parallel brain. Durable policy, workflow,
+task truth, proof, review, and backend/cloud sync all flow through Atris.
+
 | File | Purpose |
 |------|---------|
+| `atris/atris.md` | Protocol/backbone for this workspace |
 | `atris/PERSONA.md` | Communication style (read first) |
 | `atris task` | Current tasks, claims, dialogue, proof |
 | `.atris/state/tasks.projection.json` | Readable task projection for UIs/agents |
 | `atris/TODO.md` | Rendered/legacy task view only |
 | `atris/MAP.md` | Navigation (where is X?) |
 
+## Agent Contract
+
+Every agent should leave four artifacts another agent can trust:
+
+| Artifact | Where |
+|----------|-------|
+| Objective | `atris task note <id> "Goal / files / done / check"` |
+| Navigation | `atris/MAP.md` when a new route or file location is learned |
+| Change | Small git diff in declared files only |
+| Proof ready | `atris task ready <id> --proof "<commands or receipt>"` |
+| Human accept | `atris task accept <id>` |
+
+Do not rely on chat context. Put the task, file pointers, and proof on disk.
+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.
+
+Native goals and task approval are separate gates:
+
+```text
+Agent proof ready -> native goal can complete
+Human accept      -> task Done + AgentXP awarded
+```
+
+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.
+
 ## Workflow
 
 ```
@@ -28,6 +69,35 @@ BUILD → atris do     (execute tasks)
 CHECK → atris review (verify + cleanup)
 ```
 
+## Parallel Member Worktrees
+
+When multiple members, Codex/Claude subagents, or other agents may touch a repo, start in an isolated checkout:
+
+```bash
+atris worktree guide
+atris worktree start --member <member> --task "<short task>" --claim
+atris worktree start --agent <subagent> --task "<short task>"
+cd <printed path>
+atris worktree ship --message "<commit summary>" --verify "<test command>" --merge
+```
+
+This ties member/agent identity, mission/member state, branch name, isolated checkout, optional Swarlo claim, verification, push, PR, and merge together. Use `atris worktree status` before broad staging or cleanup.
+
+## Mission Autonomy
+
+Use `atris mission` when work should survive this chat or run as an autonomous loop.
+
+```
+member -> mission start --verify -> status --status active -> one bounded step -> mission tick --verify -> receipt -> complete|run|stop
+```
+
+- Start current-agent work: `atris mission start "<objective>" --owner <member> --runner codex_goal --lane code --verify "<cmd>" --stop "<condition>"`
+- Start headless Claude work: add `--runner claude --cadence "15m" --always-on`, then use `atris mission run <id> --max-ticks 4 --complete-on-pass`.
+- Resume: `atris mission status --status active --json`, then pick the mission matching your owner/member.
+- Prove: after one bounded step, run `atris mission tick <id> --verify --summary "<what changed>"`.
+- Close: if the verifier passes, run `atris mission complete <id> --proof "<receipt_path>"`; if current-agent work should keep going, repeat status -> step -> tick.
+- Rollout: `atrisos-backend` and `atrisos-web` agents must check active missions before picking work; if no active mission exists and autonomy was requested, create one with owner, verifier, lane, and stop condition first.
+
 ## Rules
 
 - [ ] 3-4 sentences max per response
@@ -35,8 +105,12 @@ CHECK → atris review (verify + cleanup)
 - [ ] Check MAP.md before touching code
 - [ ] Run `atris task list` or `atris task next` before picking work
 - [ ] Claim tasks with `atris task claim <id> --as <agent>`
-- [ ] Finish tasks with proof via `atris task finish <id> --proof "..."`
+- [ ] Move agent-completed work to Review via `atris task ready <id> --proof "..."`
+- [ ] Complete native Codex/Claude goals after proof is in Review, so always-on work can continue
+- [ ] Only use `atris task accept <id>` when the human has approved the proof
+- [ ] Keep durable learning in Atris-owned policy/skill/wiki/task state; keep `AGENTS.md` as a generated/pointer layer
 - [ ] Treat `atris/TODO.md` as a rendered view; do not manually use it as the source of truth
+- [ ] Use `atris-labs` for the Atris Labs business computer slug in docs and links
 
 ## Anti-patterns
 
@@ -56,22 +130,24 @@ CHECK → atris review (verify + cleanup)
 This workspace has a compiled agent brain.
 
 On session start, activate it first:
-`atris brain activate --root /Users/keshavrao/arena/atris-cli --verify`
+`atris brain activate --root /Users/keshavrao/arena/empire/atris-cli --verify`
 
 Load these first:
 - `atris/now.md`
 - `atris/brain/STATUS.md`
 - `atris/brain/self_improvement_ledger.md`
-- `atris/wiki/concepts/sync-language.md`
-- `atris/skills/activation/SKILL.md`
+- `atris/wiki/concepts/agent-activation-contract.md`
+- `atris/skills/atris/SKILL.md`
+- `atris/PERSONA.md`
 - `atris/MAP.md`
 - `atris/TODO.md`
+- `atris/wiki/index.md`
 
-First-message rule: follow the sync-language contract before writing to the operator.
+First-message rule: lead with the move before writing to the operator.
 Purpose: optimize for decision-speed; lead with the move, then use descriptions only when they help the operator act.
 Shape: `<operator>, today is about <move>` -> `I picked this because <why now>` -> `Ready: <draft/proof/context>` -> `Go deeper: <paths>`.
 Definitions: operator = current person or agent; move = one concrete high-leverage workflow; why now = business reason; ready = prepared action or proof; paths = 2-4 optional deeper views.
 
 Re-run after meaningful work:
-`atris brain compile --root /Users/keshavrao/arena/atris-cli`
+`atris brain compile --root /Users/keshavrao/arena/empire/atris-cli`
 <!-- ATRIS_BRAIN_COMPILE:END -->

package/README.md

@@ -138,6 +138,7 @@ atris business record atris/reports/2026-04-12-operator-recap.md --outcome mixed
 | `atris log` | Add inbox items to today's journal |
 | `atris status` | Show active work and completions |
 | `atris task` | Durable local task state with claims, dialogue, review episodes, JSON export, TODO import, TODO render, board, and sync dry-run |
+| `atris codex-goal` | Inspect or clear a completed native Codex thread goal after writing a backup, row dump, and receipt |
 | `atris learn` | Manage structured learnings |
 | `atris ingest` | Stage raw evidence into `atris/context/` and compile into `atris/wiki/` |
 | `atris loop` | Refresh wiki health, stale/orphan signals, and next ingest candidates |
@@ -154,7 +155,9 @@ atris business record atris/reports/2026-04-12-operator-recap.md --outcome mixed
 - `atris wiki --private` stores local-only sensitive notes under `.atris/presidio/`
 - `atris loop` refreshes `atris/wiki/STATUS.md` and `atris/wiki/log.md`, flags stale/orphan pages, and suggests the next ingest
 - `atris activate` loads the current wiki status so the next session starts with project memory, not just tasks
-- `atris task` keeps durable local task state and append-only events for agents while `atris/TODO.md` remains a readable regenerated project board. Use `atris task new`, `atris task delegate "..." --to <owner>`, `atris task day`, `atris task next`, `atris task say`, and `atris task finish` for the natural loop; add `--json` for headless agents. Use `atris task serve` to open the local Task Factory board with goals, work streams, lineage, proof, lessons, and the compounding chain. Every change refreshes `.atris/state/tasks.projection.json` for web/desktop. Use `atris task sync --dry-run` to preview the canonical Supabase/Swarlo task writes before any cloud mutation. Use `--via swarlo` on delegation when the live coordination layer should claim/report from the same task record. Use `--create-next` with review/finish to turn a `--next` suggestion into the next durable task. Use `atris task setup --import-todo` to bootstrap, `atris task review` to write an RSI episode, and `atris task render` to rebuild markdown if it gets clobbered. In cloud business workspaces, Supabase `tasks` is the source of truth and Swarlo is the live claim/report layer.
+- `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 while `atris/TODO.md` remains a readable regenerated project board. Human views use semantic refs like `OBL-18`; commands accept `OBL-18`, `OBL18`, full 26-char task IDs, or any unique legacy prefix, while JSON/API keep the full `id` canonical and expose `display_id` plus `legacy_ref`. Use `atris task new`, `atris task delegate "..." --to <owner>`, `atris task day`, `atris task next`, `atris task say`, and `atris task ready <id> --proof "..."` for the agent loop; once proof is in Review, the agent may complete its native goal and continue the mission loop. Human approval uses `atris task accept <id>` to move the task to Done and award Career XP, and `atris task revise <id> --note "..."` sends work back to Do. Add `--json` for headless agents. Use `atris task serve` to open the local Task Factory board with goals, work streams, lineage, proof, lessons, and the compounding chain. Every change refreshes compact `.atris/state/tasks.projection.json` for web/desktop; use `atris task show <ref>` or `atris task events --all` for the full ledger. Use `atris task sync --dry-run` to preview the canonical Supabase/Swarlo task writes before any cloud mutation. Use `--via swarlo` on delegation when the live coordination layer should claim/report from the same task record. Use `--create-next` with review/finish to turn a `--next` suggestion into the next durable task. Use `atris task setup --import-todo` to bootstrap, `atris task review` to write an RSI episode, and `atris task render` to rebuild markdown if it gets clobbered. In cloud business workspaces, Supabase `tasks` is the source of truth and Swarlo is the live claim/report layer.
 - `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
@@ -164,6 +167,7 @@ atris business record atris/reports/2026-04-12-operator-recap.md --outcome mixed
 Under the hood, Atris can keep score on real repo work.
 
 - Tasks can carry a `Verify:` command, so work can end on a deterministic check instead of pure prose.
+- Plan, do, and review now carry the same Confidence Gate: find every plausible loophole, patch it with source/proof/verifier/owner/rollback, or name it as residual risk before advancing.
 - `atris autopilot` can run that check after review and record the result in the journal.
 - Future task picks can use recent results, so Atris learns from repo-local history without claiming model retraining.
 

package/atris/AGENTS.md

@@ -4,12 +4,56 @@ Instructions for coding agents working inside this repository.
 
 ## Workflow (Default)
 
+Atris is the source of truth. This file is only an adapter for agents that read
+`AGENTS.md`; do not turn it into a parallel brain. Durable policy, workflow,
+task truth, proof, review, and backend/cloud sync all flow through Atris.
+
 1. Read `atris/PERSONA.md` and follow it (anti-slop, 3–4 sentences, ASCII for planning).
 2. Run `atris activate` to load the current working context.
 3. Use `atris/MAP.md` for navigation (file:line refs) when present.
-4. Track work in `atris/TODO.md` (target state = 0).
+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`.
 
+## Mission Autonomy
+
+Use `atris mission` when work should survive this chat or run as an autonomous loop.
+
+```
+member -> mission start --verify -> status --status active -> one bounded step -> mission tick --verify -> receipt -> complete|run|stop
+```
+
+- Start current-agent work: `atris mission start "<objective>" --owner <member> --runner codex_goal --lane code --verify "<cmd>" --stop "<condition>"`
+- Start headless Claude work: add `--runner claude --cadence "15m" --always-on`, then use `atris mission run <id> --max-ticks 4 --complete-on-pass`.
+- Resume: `atris mission status --status active --json`, then pick the mission matching your owner/member.
+- Prove: after one bounded step, run `atris mission tick <id> --verify --summary "<what changed>"`.
+- Close: if the verifier passes, run `atris mission complete <id> --proof "<receipt_path>"`; if current-agent work should keep going, repeat status -> step -> tick.
+
+## Agent Contract
+
+Leave four durable artifacts:
+
+| Artifact | Where |
+|----------|-------|
+| Objective | `atris task note <id> "Goal / files / done / check"` |
+| Navigation | `atris/MAP.md` when a route or file location is learned |
+| Change | Small git diff in declared files only |
+| Proof ready | `atris task ready <id> --proof "<commands or receipt>"` |
+| Human accept | `atris task accept <id>` |
+
+Native goals and task approval are separate gates:
+
+```text
+Agent proof ready -> native goal can complete
+Human accept      -> task Done + Career XP awarded
+```
+
+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.
+
+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.
+
 ## Repo Layout
 
 - `bin/atris.js` — CLI entrypoint + routing + natural-language entry.
@@ -17,6 +61,7 @@ Instructions for coding agents working inside this repository.
 - `lib/` — journal/task/file helpers (`journal`, `file-ops`, `state-detection`).
 - `utils/` — auth/API/config/update-check and cloud execution helpers.
 - `atris.md` — master spec template copied into user projects.
+- `atris/atris.md` — workspace protocol/backbone.
 
 ## Notes
 

package/atris/CLAUDE.md

@@ -28,10 +28,31 @@ This displays the Atris welcome visualization. Show it to the user, then respond
 - Run `atris activate` to load the current working context.
 - If `atris/wiki/STATUS.md` exists, treat it as the current memory snapshot for the project.
 
+## Agent Contract
+
+This project shape is agent-agnostic: Claude Code, Cursor, Codex, OpenClaw, Windsurf, and similar agents should all use the same disk-backed contract.
+
+Atris is the source of truth. This file is only an adapter for Claude Code; do not turn it into a parallel brain. Durable policy, workflow, task truth, proof, review, and backend/cloud sync all flow through Atris.
+
+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.
+
+Native goals and task approval are separate gates:
+
+```text
+Agent proof ready -> native goal can complete
+Human accept      -> task Done + AgentXP awarded
+```
+
+Always-on agents should complete their native goal after proof is in Review, 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.
+
+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.
+
 ## Core Files
 
 - `atris/MAP.md` — navigation (use file:line references)
-- `atris/TODO.md` — current work queue (target state = 0)
+- `atris task` — current tasks, claims, dialogue, and proof
+- `.atris/state/tasks.projection.json` — readable task projection for UIs/agents
+- `atris/TODO.md` — rendered/legacy task view only
 - `atris/logs/YYYY/YYYY-MM-DD.md` — journal (Inbox + Completed)
 - `atris/wiki/STATUS.md` — current wiki health and next ingest targets
 - `atris/wiki/index.md` — local knowledge index
@@ -41,6 +62,20 @@ This displays the Atris welcome visualization. Show it to the user, then respond
 
 `atris plan` → `atris do` → `atris review`
 
+## Mission Autonomy
+
+Use `atris mission` when work should survive this chat or run as an autonomous loop.
+
+```
+member -> mission start --verify -> status --status active -> one bounded step -> mission tick --verify -> receipt -> complete|run|stop
+```
+
+- Start current-agent work: `atris mission start "<objective>" --owner <member> --runner codex_goal --lane code --verify "<cmd>" --stop "<condition>"`
+- Start headless Claude work: add `--runner claude --cadence "15m" --always-on`, then use `atris mission run <id> --max-ticks 4 --complete-on-pass`.
+- Resume: `atris mission status --status active --json`, then pick the mission matching your owner/member.
+- Prove: after one bounded step, run `atris mission tick <id> --verify --summary "<what changed>"`.
+- Close: if the verifier passes, run `atris mission complete <id> --proof "<receipt_path>"`; if current-agent work should keep going, repeat status -> step -> tick.
+
 If the task produces durable project knowledge, update `atris/wiki/` or run the local wiki flow (`atris ingest`, `atris query`, `atris lint`).
 
 ## Rules (Non‑Negotiable)

package/atris/GEMINI.md

@@ -36,9 +36,22 @@ This is the Atris boot sequence. Show the output to the user, then respond natur
 
 `atris plan` → `atris do` → `atris review`
 
+## Mission Autonomy
+
+Use `atris mission` when work should survive this chat or run as an autonomous loop.
+
+```
+member -> mission start --verify -> status --status active -> one bounded step -> mission tick --verify -> receipt -> complete|run|stop
+```
+
+- Start current-agent work: `atris mission start "<objective>" --owner <member> --runner codex_goal --lane code --verify "<cmd>" --stop "<condition>"`
+- Start headless Claude work: add `--runner claude --cadence "15m" --always-on`, then use `atris mission run <id> --max-ticks 4 --complete-on-pass`.
+- Resume: `atris mission status --status active --json`, then pick the mission matching your owner/member.
+- Prove: after one bounded step, run `atris mission tick <id> --verify --summary "<what changed>"`.
+- Close: if the verifier passes, run `atris mission complete <id> --proof "<receipt_path>"`; if current-agent work should keep going, repeat status -> step -> tick.
+
 ## Rules
 
 - Plan = ASCII visualization + approval gate. Do not execute during planning.
 - Execute step-by-step, verify as you go, update artifacts (`TODO.md`, `MAP.md`) when reality changes.
 - Delete completed tasks (validator cleans to target state = 0).
-

package/atris/atris.md

@@ -122,10 +122,21 @@ 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:\nFIX:`. Plan does not move to do without signoff. Codex is optional escalation when `ATRIS_USE_CODEX=1` or the task carries `[codex]`.
+- **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:
+
+```
+am I factually confident enough to move this forward?
+  -> find loopholes: stale source, missing owner, weak proof, bad rollback, hidden risk
+  -> patch each loophole with source, verifier, proof, owner, rollback, or blocked note
+  -> advance only when known loopholes are patched, verified, or named as residual risk
+```
+
+100% confidence is not a vibe. It means every known loophole has been closed or explicitly carried as residual risk.
+
 State the next stage:
 
 ```

package/atris/atrisDev.md

@@ -470,7 +470,7 @@ Enhanced sync logic with auto-pull and conflict resolution.
 
 **The atrisDev Protocol** is a universal workflow that any coding agent can follow to produce high-quality output. When agents follow this protocol, they build features systematically with human approval gates and proper documentation, using small, low-risk changes that compound over time.
 
-**This protocol works with ANY agent:** Claude Code, Cursor, Windsurf, GitHub Copilot, or any LLM-based coding assistant.
+**This protocol works with ANY agent:** Claude Code, Cursor, Codex, OpenClaw, Windsurf, GitHub Copilot, or any LLM-based coding assistant.
 
 ---
 
@@ -637,7 +637,8 @@ Workflow: Navigator (plan) → Executor (build) → Validator (verify)
 Key behaviors:
 - Read PERSONA.md first (3-4 sentences, ASCII visuals)
 - Check MAP.md for file:line refs
-- Update TODO.md (claim tasks, delete when done)
+- Use `atris task` for claims, proof, ready, and accept
+- Treat TODO.md as a rendered view; regenerate it instead of hand-editing tasks
 ```
 
 ### Checklist

package/atris/context/README.md

@@ -0,0 +1,11 @@
+# Context
+
+Raw source material lives in `atris/context/`.
+Compiled memory belongs in `atris/wiki/`.
+
+## Rules
+
+- Drop source files or source packs here before compiling them into the wiki.
+- Treat source files as immutable evidence. If the source changes, add a new dated copy.
+- Keep compiled summaries, briefs, and durable facts in the wiki instead of this folder.
+- Use `atris/context/_ingest/` for staged ingest packs and receipts.

package/atris/features/company-brain-sync/validate.md

@@ -209,13 +209,13 @@ Validated behavior:
 
 - Publish `atris@3.15.12`.
 - Deploy the backend workspace snapshot patch from `atrisos-backend`.
-- After deploy, run a Pallet smoke:
+- After deploy, run an ExampleCo smoke:
 
 ```bash
 npm i -g atris@3.15.12
-cd ~/arena/atris-business/pallet
-atris pull pallet --keep-local --only atris/wiki --timeout 120
-atris push pallet --only atris/wiki --dry-run
+cd ~/arena/atris-business/example-co
+atris pull example-co --keep-local --only atris/wiki --timeout 120
+atris push example-co --only atris/wiki --dry-run
 ```
 
 - DoorDash post-publish smoke:
@@ -240,7 +240,7 @@ Missing validation:
 - remote delete does not destroy local modified work end-to-end
 - parent folder junk is ignored by the push planner; still needs a full command fixture
 - long-running watcher needs an integration test with a mocked local edit and no real cloud calls
-- Pallet shipped-command smoke test from a real Pallet-shaped workspace
+- ExampleCo shipped-command smoke test from a real ExampleCo-shaped workspace
 - npm publication after refreshing the invalid npm token
 
 ## Release Gate

package/atris/learnings.jsonl

@@ -0,0 +1 @@
+{"ts":"2026-05-08T02:32:38.257Z","type":"pitfall","key":"narrow-grep-hides-matches","insight":"When operator says X exists in our code and a single-pattern grep returns 0 hits, do NOT conclude it does not exist. Run wider grep -rn first (whole backend/, not one subdir) before doubting. Tonight 2026-05-08: grepped \"gpt-5\\.5|gpt5\\.5|gpt-5p5\" in clients/ only, missed 20+ matches in routers/atris2_router.py + tests/, told operator gpt-5.5 was not wired. Operator was right.","confidence":5,"source":"observed","files":[]}

package/atris/policies/atris-design.md

@@ -21,6 +21,8 @@ this is the "distribution center" — statistically average, aesthetically dead.
 
 **avoid:** inter, roboto, open sans, lato, arial, montserrat, system defaults. also avoid monospace as lazy shorthand for "technical/developer" vibes.
 
+**never:** all-caps UI labels, tracked-uppercase labels, faux small-caps, or eyebrow-style metadata on ordinary product surfaces. Keshav strongly dislikes this style. Use natural title case or sentence case instead: `Threads`, `Active tasks`, `Team`, not `THREADS`, `ACTIVE TASKS`, or letter-spaced microcopy.
+
 **try instead:**
 - instead of inter → instrument sans, plus jakarta sans, outfit
 - instead of roboto → onest, figtree, urbanist

package/atris/skills/aeo/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: aeo
 description: "AI Engine Optimization — write content engineered to get cited by ChatGPT, Claude, and Gemini. Not SEO. Triggers on: aeo, AI engine, llm citation, get cited, write for ai."
-when_to_use: "Use when the user wants content that ranks in AI answers (not Google SERP). Examples: 'write an AEO page', 'get Pallet cited by ChatGPT', 'aeo for our recruiting page', 'make this quotable by LLMs'."
+when_to_use: "Use when the user wants content that ranks in AI answers (not Google SERP). Examples: 'write an AEO page', 'get ExampleCo cited by ChatGPT', 'aeo for our recruiting page', 'make this quotable by LLMs'."
 version: 0.1.0
 allowed-tools: Read, Write, Edit, Glob, Grep, Bash
 tags:
@@ -46,7 +46,7 @@ Entity graph lives in the **customer's EC2 workspace** (not agent_files, not DB)
 ## The 10 rules (enforced by the endpoint + skill self-check)
 
 1. **Front-load the claim.** LLMs quote sentence 1 of a paragraph. No throat-clearing.
-2. **Name entities explicitly.** "Pallet" not "a leading freight platform." Entity density is how LLMs disambiguate and cite.
+2. **Name entities explicitly.** "ExampleCo" not "a leading freight platform." Entity density is how LLMs disambiguate and cite.
 3. **Canonical definition.** One sentence owns `X is Y that does Z` for the category. Make it liftable.
 4. **Q&A scaffolding.** H2s in question form: "What is X?" "How does X work?" — matches the prompts LLMs actually get.
 5. **Declarative stats with sources.** "$2.3B market (McKinsey 2025)" beats "a growing market." Citable atoms.

package/atris/skills/atris/SKILL.md

@@ -1,76 +1,29 @@
 ---
 name: atris
-description: Atris workflow enforcement for repos using atris/ (MAP, TODO, journal, features, plan-do-review, anti-slop). Use when the user asks to follow the Atris system or mentions atris, MAP.md, TODO.md, journal/logs, features, plan/do/review, or anti-slop policies.
-version: 2.0.0
-tags:
-  - atris
-  - workflow
-  - memory
-  - navigation
-  - anti-slop
+description: Atris workspace navigation for atris repos, TODO files, tasks, MAP.md, backlog, and where-is-X questions.
+allowed-tools: Read, Bash, Glob, Grep, Write, Edit
 ---
 
 # Atris Skill
 
-## Scope
-- Use in repos that contain `atris/`, or when the user invokes Atris flow.
-- If unsure, ask one question before acting.
+## IMPORTANT: First Interaction
 
-## Required context
-- Read `atris/atris.md`, `atris/PERSONA.md`, `atris/MAP.md`, `atris/TODO.md`.
-- Read today's journal `atris/logs/YYYY/YYYY-MM-DD.md` when planning or executing.
-- Before nontrivial execution, scan the recent entries in `atris/lessons.md` — patterns repeat.
-- Read `atris/features/<slug>/` only when opening or closing a feature.
+**On your FIRST message in any Atris project, IMMEDIATELY run:**
 
-## MAP-first
-- Read `atris/MAP.md` before any search.
-- If MAP lacks the answer, run one search and update MAP.
-
-## Operating rules (from atris.md)
-Before changing anything, state: goal, files in scope, what "done" means, how it will be checked, what happens if it fails.
-
-Do not:
-- execute if another agent owns the same task or files
-- mark complete without running the task's `Verify:` command
-- take irreversible actions without approval from the human
-- hide state outside markdown, logs, diffs, or the journal
-- edit the reward config, authority policy, or `atris.md` itself
-
-If you cannot honor these, stop, write why in the journal, and ask.
-
-## Task shape
-Every task in `TODO.md` declares:
+```bash
+atris atris.md
 ```
-**T#:** <title> [tier] [kind]
-  **Owner:** <slug>
-  **Files:** <paths touched>
-  **Exit:** <observable done condition>
-  **Verify:** <shell command, exits 0 on success>
-  **After:** <deps or none>
-  **Rollback:** <commit/checkpoint or "none (gray)">
-```
-Tier: `agent` proceeds, `gray` queues for approval, `human` never attempted.
 
-## Workflow
-Move one task through plan → do → review:
-- **plan** — read relevant files, ASCII visualization, wait for approval. No code.
-- **do** — claim the task (In Progress + `Claimed by: <agent> at <ISO>`), execute step by step, update `MAP.md` and the journal as reality changes.
-- **review** — run `Verify:`, read diff, run tests, append one-line lesson to `lessons.md`, move task to Completed.
+Show the full ASCII output to the user. This displays the Atris welcome visualization with workspace stats. Do this BEFORE responding to whatever the user said.
 
-Deeper work uses `atris/features/<slug>/` with `idea.md` (plan), `build.md` (steps), `validate.md` (checks). The task points; the triptych holds the long form.
+## Workflow
 
-## Failure smells
-If you see these, stop and flag:
-- **loop** — same suggestion tick after tick, nothing changes on disk
-- **drift** — MAP.md refs no longer match the code
-- **stale task** — references a file or symbol that no longer exists
-- **hidden side effect** — external state changed without a queued approval
-- **unverifiable completion** — marked complete without `Verify:` actually running
+Detect: Project has `atris/` folder with MAP.md, TODO.md, PERSONA.md
 
-## Policies
-- Enforce `atris/policies/ANTISLOP.md` always.
-- Load `atris-design.md`, `atris-backend.md`, or `writing.md` only when that domain is in scope.
-- For authority tiers, see `policies/AGENT_AUTHORITY.md`.
+Commands: plan → do → review
 
-## Improvement loop
-After review, if output missed intent or failed verification, append one line to `atris/lessons.md`. If a lesson repeats 2-3 times, promote it into the relevant policy and prune.
+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

package/atris/skills/design/SKILL.md

@@ -54,6 +54,8 @@ Font alternatives: instead of Inter → Instrument Sans, Plus Jakarta Sans, Outf
 
 **Hierarchy:** 2-3 text levels max. don't mix 5 competing styles.
 
+**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.
 
 ## The AI Slop Test

package/atris/skills/imessage/SKILL.md

@@ -28,9 +28,26 @@ atris imessage doctor --json
 atris imessage recent "+15555555555" --limit 20
 ```
 
-4. Never send a message unless the user approved the exact recipient and exact text.
+4. Resolve named contacts through the cached local lookup command. Use `--refresh` only when the cache is stale or the result looks wrong.
 
-5. For sending, use the project-approved local iMessage path only after explicit approval.
+```bash
+atris imessage lookup --name "Exact Contact Name" --json
+atris imessage lookup --name "myself" --json
+```
+
+If lookup returns `unique: true`, use `primary.handle` for the send. If lookup returns `ambiguous: true`, ask one concise clarification with the candidate names. If it returns no matches, ask for a phone number or exact contact name. Do not scan Contacts manually or loop over AppleScript; the CLI caches lookup results in `~/.atris/cache/imessage-contacts.json`.
+
+5. Never send a message unless the user approved the exact recipient and exact text.
+
+6. For sending, use the fast local send command only after explicit approval.
+
+```bash
+atris imessage send --to "+15555555555" --text "Exact approved text" --approved --json --receipt
+```
+
+The command normalizes US 10-digit phone numbers to `+1...`, checks `doctor`, sends through the local Messages AppleScript path using `service type = iMessage`, and returns JSON proof after the latest-outgoing Messages DB row settles. Use `--receipt` inside an Atris workspace when the action needs a durable `atris/runs/imessage-send-*.md` receipt.
+
+If the recipient name is ambiguous, ask one concise clarification before sending. If the user gave a phone number or exact resolved handle, do not search the repo first.
 
 ## Status Meaning
 

package/atris/skills/loop/SKILL.md

@@ -16,7 +16,7 @@ Schedules the recurring autopilot heartbeat. One tick fires roughly every 13–1
 ## What it does
 
 1. Calls `CronCreate` with a recurring schedule (off-clock minute to avoid fleet sync at :00 / :30)
-2. The cron prompt invokes `/autopilot`, which runs ONE plan→do→review tick on the next-priority work
+2. The cron prompt first invokes `atris mission run --due --max-ticks 1 --complete-on-pass`; if no mission is due, it invokes `/autopilot`
 3. Returns the cron job id so the user can stop it later with `CronDelete`
 4. Lists the active cron jobs via `CronList` so the user can see the heartbeat is alive
 
@@ -28,7 +28,7 @@ The agent then:
 
 1. Calls `CronCreate` with these args (use whatever off-clock minute you land on, do not pin to :00 or :30):
    - `cron`: `"*/13 * * * *"` (every 13 min) for tight loops, or `"7 * * * *"` (hourly at :07) for slow loops
-   - `prompt`: `"/autopilot — run one tick. find the next thing in atris/TODO.md or the inbox, plan it, do it, review it. one task only. then stop. do not start a conversation."`
+   - `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)
 2. After creating, calls `CronList` and shows the user the active cron jobs.
@@ -51,14 +51,15 @@ If the user says "kill all loops", call `CronList`, then `CronDelete` for every
 
 ## Why this is the heartbeat
 
-`/autopilot` is one tick. `/loop` is the schedule. Together they are the heartbeat:
+`atris mission` is the north star. `/autopilot` is the fallback tick. `/loop` is the schedule:
 
 ```
-/loop  →  CronCreate('*/13 * * * *', '/autopilot')
+/loop  →  CronCreate('*/13 * * * *', 'atris mission run --due ... || /autopilot')
               ↓
           every ~13 min while Claude Code is idle:
               ↓
-          /autopilot  →  one tick
+          due mission? → one mission tick
+          no mission?  → one autopilot tick
               ↓
           plan → do → review → stop
               ↓

package/atris/skills/magic-inbox/SKILL.md

@@ -71,7 +71,7 @@ Returns email + calendar + slack in one structured response:
   },
   "calendar": {
     "events": [
-      {"summary": "Meeting with Grace", "start": "...", "attendees": ["grace@pallet.com"]}
+      {"summary": "Meeting with Grace", "start": "...", "attendees": ["grace@example.com"]}
     ],
     "count": 1
   },