atris 2.6.2 → 3.0.0

package/README.md

@@ -1,77 +1,167 @@
 # atris
 
-**atris** is a self improving context layer for your agent. Works with coding agents like Claude Code and Cursor.
+**atris** is an operating system for intelligence.
+
+It turns any repo into an AI workspace with shared context, a `plan -> do -> review` loop, daily logs, feature packs, and reusable skills.
 
 ## For Coding Agents
 
-**If you're a coding agent (Claude Code, Cursor, Windsurf, Copilot, etc.) reading this:**
+If you're an agent, run:
 
-When the user asks to build/plan/fix something, run:
 ```bash
 atris
 ```
 
-Follow the instructions in the output. The full protocol is in `atris.md`.
+Then read the workspace's `atris/atris.md` and follow it exactly. `atris.md` is the source of truth.
 
 ---
 
+## What Atris Gives You
+
+- An AI workspace on top of any repo
+- A strict `plan -> do -> review` loop
+- Daily logs, task tracking, feature packs, and project memory
+- Skills, team members, integrations, and cloud sync when you need them
+
+## Critical Files
+
+| File | Purpose |
+|------|---------|
+| `atris/atris.md` | God file. Protocol and source of truth |
+| `atris/MAP.md` | Navigation index with file:line refs |
+| `atris/TODO.md` | Shared task queue |
+| `atris/logs/YYYY/YYYY-MM-DD.md` | Daily log, inbox, notes, completions |
+| `atris/features/` | Feature packs with `idea.md`, `build.md`, `validate.md` |
+| `atris/skills/` | Reusable skills for agents |
+| `atris/team/` | Team member specs and local context |
+
+```text
+atris/
+├── atris.md
+├── MAP.md
+├── TODO.md
+├── logs/
+├── features/
+├── skills/
+└── team/
+```
+
 ## Install
 
 ```bash
 npm install -g atris
+atris --version
 ```
 
-## Quick Start
+Requires Node.js 18+.
+
+If you want Atris cloud workspaces, businesses, or integrations, run `atris setup` after install.
+
+## How To Run Atris
 
 ```bash
 cd your-project
-atris init    # Creates atris/ folder
-atris         # Loads context, ready to build
+atris init
+atris
 ```
 
-Then describe what you want to build. The agent will:
-0. (Optional) Explore with `atris brainstorm` if uncertain
-1. Show you a visualization
-2. Wait for approval
-3. Create `atris/features/[name]/idea.md` + `build.md` + `validate.md`
-4. Execute step by step
-5. Validate (fill in validate.md, harvest lessons if anything surprised you)
+`atris init` scaffolds the workspace, including `atris/wiki/`. `atris` loads context and hands the workflow off to `atris/atris.md`.
+
+If you're still shaping the idea, use `atris brainstorm`. If you want Atris to keep cycling, use `atris run` or `atris autopilot`. If you want the repo brain kept honest, use `atris loop`. `atris activate` now surfaces wiki state from `atris/wiki/STATUS.md` when it exists.
 
-Commands: `brainstorm` (optional) → `plan` → `do` → `review`
+Core loop: `plan` -> `do` -> `review`
 
-Works with: Claude Code, Cursor, Windsurf, GitHub Copilot, any agent.
+Works with Claude Code, Cursor, Windsurf, Codex, GitHub Copilot, and other coding agents.
 
-## Experiments
+## Core Commands
 
-Atris also supports Karpathy-style keep/revert loops inside `atris/experiments/`.
+| Command | Purpose |
+|---------|---------|
+| `atris` | Load context and start |
+| `atris init` | Scaffold an Atris workspace |
+| `atris brainstorm` | Explore before planning |
+| `atris plan` | Create the plan/spec |
+| `atris do` | Execute work |
+| `atris review` | Validate work and capture learnings |
+| `atris run` | Auto-chain `plan -> do -> review` |
+| `atris autopilot` | Guided loop with approvals |
+| `atris log` | Add inbox items to today's journal |
+| `atris status` | Show active work and completions |
+| `atris learn` | Manage structured learnings |
+| `atris ingest` | Fast local-first wiki ingest into `atris/wiki/` |
+| `atris loop` | Refresh wiki health, stale/orphan signals, and next ingest candidates |
+| `atris wiki` | Full wiki namespace: ingest, query, lint, search, log, and loop |
+| `atris experiments` | Run Karpathy-style keep/revert packs |
+
+## Built-In Systems
+
+- `atris learn` stores structured project memory in `atris/learnings.jsonl`
+- `atris wiki` keeps repo memory in `atris/wiki/` by default, with `--cloud` when you want the remote workspace path
+- `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 experiments` runs Karpathy-style keep/revert loops in `atris/experiments/`
+- `atris pull` and `atris push` sync cloud workspaces and journals
+
+## Benchmark Harness
+
+Atris ships one public head-to-head benchmark harness for comparing a pinned
+single-model baseline against a coordinated stack run on the same task brief.
+
+Quickstart:
 
 ```bash
-atris experiments init self-heal
-atris experiments validate
-atris experiments benchmark
+node bin/atris.js experiments validate endstate-baseline
+node bin/atris.js experiments validate endstate-stack
+node bin/atris.js experiments run endstate-baseline --dry-run
+node bin/atris.js experiments run endstate-stack --dry-run
+node bin/atris.js experiments compare endstate
 ```
 
-## Update
+One-command rehearsal:
 
 ```bash
-atris upgrade     # Install latest from npm
-atris update      # Sync local files to new version
+node bin/atris.js experiments replay endstate
 ```
 
+What to inspect:
+
+- receipts land in `atris/experiments/endstate-baseline/artifacts/` and
+  `atris/experiments/endstate-stack/artifacts/`
+- scores append to each pack's `results.tsv`
+- `atris experiments compare endstate` prints the latest side-by-side scorecard
+- `atris experiments replay endstate` runs the full public dry-run rehearsal
+- the benchmark contract lives at `atris/features/endstate/contract.md`
+- the verification log lives at `atris/features/endstate/validate.md`
+
+The stack wins Level 1 only if it beats the baseline on total score and does
+not lose the reviewed completion category.
+
 ## Skills
 
-Atris includes agent-agnostic skills that work with Claude, Cursor, Codex, any LLM:
+Atris ships a real skill catalog in `atris/skills/`, not just one workflow file.
 
-| Skill | Purpose |
-|-------|---------|
-| atris | Workflow enforcement + plan/do/review |
-| autopilot | PRD-driven autonomous execution |
-| backend | Backend architecture anti-patterns |
-| design | Frontend aesthetics policy |
-| meta | Metacognition for agents |
-| writing | Essay process with approval gates |
+Examples:
+- `atris`, `autopilot`, `autoresearch`, `wiki`, `loop`
+- `backend`, `design`, `copy-editor`, `meta`, `writing`
+- `github`, `email-agent`, `calendar`, `drive`, `slack`, `notion`, `slides`, `x-search`, `youtube`, `ramp`
+- `apps`, `create-app`, `create-member`, `memory`, `magic-inbox`, `improve`, `skill-improver`, `flow`
+
+```bash
+atris skill list
+atris skill audit [name]
+atris skill fix [name]
+atris skill create <name>
+atris skill link [--all]
+```
 
-Install to Codex: `cp -r atris/skills/[name] ~/.codex/skills/`
+For Codex, copy any skill folder into `~/.codex/skills/`.
+
+## Update
+
+```bash
+atris upgrade     # Install latest from npm
+atris update      # Sync local workspace files to new version
+```
 
 ---
 

package/atris/CLAUDE.md

@@ -26,21 +26,25 @@ This displays the Atris welcome visualization. Show it to the user, then respond
 
 - Read `atris/PERSONA.md` (tone + operating rules).
 - 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.
 
 ## Core Files
 
 - `atris/MAP.md` — navigation (use file:line references)
 - `atris/TODO.md` — current work queue (target state = 0)
 - `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
 - `atris/atris.md` — protocol/spec
 
 ## Default Loop
 
 `atris plan` → `atris do` → `atris review`
 
+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)
 
 - 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

@@ -11,6 +11,7 @@
 1. Load context (ONE time, remember for session):
    - `atris/logs/YYYY/YYYY-MM-DD.md` (today's journal)
    - `atris/MAP.md` (navigation overview)
+   - `atris/wiki/STATUS.md` (wiki health + next ingest targets, if present)
    - `atris/team/*.md` (all agent specs)
 
 2. Output this EXACT box:
@@ -161,6 +162,8 @@ Specs loaded at activate from `team/*.md`
 | `MAP.md` | Where is X? (navigation) |
 | `TODO.md` | Task queue (target: 0) |
 | `logs/YYYY/MM-DD.md` | Journal (daily) |
+| `wiki/STATUS.md` | Local project memory health |
+| `wiki/index.md` | Local knowledge index |
 | `PERSONA.md` | Communication style |
 | `team/` | Agent behaviors |
 | `atrisDev.md` | Full spec (reference) |
@@ -196,6 +199,7 @@ Context window = cache. Disk = truth. Route discoveries as they happen.
 | Code location       | MAP.md               | file:line reference  |
 | New task            | TODO.md              | Task + exit condition |
 | Decision / tradeoff | Journal → Notes      | Timestamped line     |
+| Durable project knowledge | wiki/               | page update + STATUS refresh |
 | Something learned   | lessons.md           | One-line lesson      |
 | Work finished       | Journal → Completed  | C#: description      |
 

package/atris/features/README.md

@@ -90,6 +90,30 @@ Close remaining audit gaps from self-audit
 
 ### Completed Features
 
+#### endstate
+Public benchmark for proving a coordinated stack beats a pinned single-model baseline
+- **Files:** atris/features/endstate/*, commands/autopilot.js, commands/experiments.js, commands/loop.js, lib/wiki.js
+- **Status:** complete
+- **Keywords:** benchmark, endstate, autopilot, experiments, eval
+- **What:** Defines the benchmark, scorecard, and build plan for a head-to-head run across `atris-cli` and `atrisos-backend`
+- **Completed:** 2026-04-08
+
+#### wiki-loop
+Deterministic upkeep loop for the local wiki
+- **Files:** commands/loop.js, lib/wiki.js, commands/wiki.js, bin/atris.js, test/commands.test.js, test/cli-smoke.test.js, atris/skills/loop/SKILL.md, atris/features/wiki-loop/*
+- **Status:** complete
+- **Keywords:** wiki, loop, upkeep, stale, orphan, status
+- **What:** Adds `atris loop` and `atris wiki loop` to refresh `STATUS.md` + `log.md`, detect stale/orphan pages, and suggest the next ingest without auto-push
+- **Completed:** 2026-04-07
+
+#### wiki
+Local-first project wiki with cloud opt-in
+- **Files:** lib/wiki.js, commands/wiki.js, commands/init.js, commands/activate.js, commands/pull.js, commands/push.js, bin/atris.js, test/commands.test.js, test/cli-smoke.test.js, atris/skills/wiki/SKILL.md, atris/wiki/*
+- **Status:** complete
+- **Keywords:** wiki, ingest, local-first, cloud, memory
+- **What:** Canonical `atris/wiki/` scaffold, local-first ingest/query/lint, `--only wiki` sync alias, init/activate integration, project-local wiki skill, seeded repo wiki
+- **Completed:** 2026-04-07
+
 #### self-improving-loop
 Make Atris recursive — validate.md lessons feed back into the next idea.md
 - **Files:** atris/lessons.md (new), atris.md, atris/team/navigator.md, atris/team/validator.md, atris/MAP.md

package/atris/skills/autopilot/SKILL.md

@@ -1,101 +1,100 @@
 ---
 name: autopilot
-description: PRD-driven autonomous execution - give it a task, it loops until done Triggers on "autopilot", "autonomous", "get it done", "finish this", "ship it".
-version: 1.0.0
+description: "Run ONE autopilot tick. Reads identity (flow) + horizon (endgame), shows a visual status block, picks the next [endgame] task or seeds a new endgame at boundaries, then executes plan→do→review. Lessons compound to atris/lessons.md. Triggers on: autopilot, run one tick, ship one thing, do the next thing, get this done."
+version: 3.2.0
 tags:
   - autopilot
   - workflow
-  - automation
+  - tick
+  - endgame
+  - flow
 ---
 
-# Autopilot Skill
+> **The two-engine architecture:** /flow chains forward from identity (who you are → next move). /endgame chains backward from horizon (where you're going → next move). They meet at the same intersection — the next thing /autopilot should ship. Each tick reads both sides and shows them in the visual status block.
 
-Autonomous task execution. Plan → Do → Review loop until acceptance criteria pass.
+## Visual status block
 
-## When to Use
-
-- User says "get this done" or "ship it"
-- User describes a feature/bug and wants hands-off execution
-- Any task that can be validated with acceptance criteria
-
-## Process
+Every tick prints this BEFORE scanning for work, so you can see the loop's state at a glance:
 
 ```
-┌───────────────────────────────────────────────────────┐
-│  INPUT: "Add dark mode toggle"                        │
-│                                                       │
-│  1. GENERATE PRD                                      │
-│     - Type: feature or bug (auto-detect)              │
-│     - Acceptance criteria (testable conditions)       │
-│     - Priority: 1 (single story)                      │
-│                                                       │
-│  2. LOOP (max 5 iterations)                           │
-│     ┌──────────────────────────────────────┐          │
-│     │ PLAN: Navigator creates tasks        │          │
-│     │   - Read MAP.md for file locations   │          │
-│     │   - ASCII diagram of approach        │          │
-│     │   - Add tasks to TODO.md             │          │
-│     │   - Signal: [PLAN_COMPLETE]          │          │
-│     ├──────────────────────────────────────┤          │
-│     │ DO: Executor builds                  │          │
-│     │   - Implement each task              │          │
-│     │   - Verify changes work              │          │
-│     │   - Commit changes                   │          │
-│     │   - Signal: [DO_COMPLETE]            │          │
-│     ├──────────────────────────────────────┤          │
-│     │ REVIEW: Validator checks             │          │
-│     │   - Check acceptance criteria        │          │
-│     │   - If fail: [REVIEW_FAILED] reason  │          │
-│     │   - If pass: [COMPLETE]        │
-│     └──────────────────────────────────────┘          │
-│                                                       │
-│  3. OUTPUT                                            │
-│     - prd.json: PRD with passes: true                 │
-│     - progress.txt: Execution log                     │
-│     - Journal: Completion logged                      │
-└───────────────────────────────────────────────────────┘
+  ┌──────────────────────────────────────────────────────────────┐
+  │ tick · 14:23                                                 │
+  │ identity:  building atris-business cloud for design partners │
+  │ horizon:   wiki-from-atris-labs                              │
+  │            atris-cli wiki has 3 new pages from atris-labs    │
+  │ progress:  ████████░░░░  6/9 endgame steps                   │
+  └──────────────────────────────────────────────────────────────┘
 ```
 
-## Acceptance Criteria Templates
+- **identity** comes from `atris/PERSONA.md` (first non-trivial line)
+- **horizon** comes from the `## Endgame` section in `atris/TODO.md`
+- **progress** counts `[endgame]`-tagged tasks in Backlog vs `T#/W#/E#`-prefixed entries in Completed
+
+If identity is missing, edit PERSONA.md. If no horizon is active, /endgame seeds one from inbox / wiki / lessons.
+
+# /autopilot
+
+Runs ONE plan→do→review tick anchored to the current endgame. If no endgame is active, seeds one from the inbox or wiki signals first. Not a recurring loop — call `/loop` for that.
+
+## When to use
+
+- User says "run one tick", "do the next thing", "ship one thing", "get this done"
+- The cron job from `/loop` invokes this on each fire
+
+## What ONE tick does
 
-**Feature:**
-- Feature implemented and working as described
-- Tests pass (if test suite exists)
-- Build passes
-- Code follows project patterns (check MAP.md)
+1. **Read state** — load `atris/TODO.md`. Look for the `## Endgame` section header and `[endgame]`-tagged tasks in `## Backlog`.
+2. **Boundary check** — if no `## Endgame` section exists, OR every `[endgame]`-tagged task in Backlog is done/missing, invoke `/endgame` first to seed the next horizon. `/endgame` will write a new `## Endgame` section + tagged backlog tasks to TODO.md.
+3. **Execute** — run `atris autopilot --auto --iterations=1` via Bash. The CLI prefers `[endgame]`-tagged backlog tasks (priority 0) over reactive signals (priority 1+). One task per tick.
+4. **Stop** — show the output, do not start a conversation, do not chain. The next tick is the cron's job.
 
-**Bug:**
-- Bug is fixed and no longer reproducible
-- Regression test added (if applicable)
-- Build passes
-- No new bugs introduced
+## How to invoke
 
-## Commands
+When the user (or cron) invokes `/autopilot`:
 
-```bash
-# With description
-atris autopilot "Add dark mode toggle"
+```
+1. Read atris/TODO.md
+2. If TODO.md has no `## Endgame` section OR no `[endgame]` tasks in Backlog:
+     → Invoke `/endgame` first (it will write the new endgame to TODO.md)
+3. Run: atris autopilot --auto --iterations=1
+4. Show output
+5. Stop
+```
 
-# Bug fix
-atris autopilot --bug "Login fails on Safari"
+## Boundary behavior
 
-# From TODO.md backlog
-atris autopilot --from-todo
+The whole point of the architecture: **finish the current endgame before picking another.** Reactive signals (stale pages, broken refs) are fallbacks, not the main road. The main road is endgame → endgame → endgame, set by the human or seeded from inbox at every boundary.
 
-# With options
-atris autopilot "Add feature" --iterations=3 --verbose
 ```
+TODO.md state                          → tick action
+─────────────────────────────────────────────────────────────────────
+no ## Endgame section                  → /endgame to seed, then run tick
+## Endgame exists, [endgame] tasks 0   → /endgame to pick next, then run tick
+## Endgame exists, [endgame] tasks 1+  → run tick (pick next [endgame] task)
+no endgame anywhere, no inbox, clean   → loop journals "nothing left", stops
+```
+
+## Variants
 
-## Stop Conditions
+- `atris autopilot --dry-run` — preview what it would do, do not execute
+- `atris autopilot --auto --iterations=N` — run up to N ticks back-to-back (still one task per tick, boundary checks between)
+- `atris autopilot "<task description>"` — seed a new inbox item, then run
 
-1. `[COMPLETE]` — All acceptance criteria met
-2. Max iterations reached (default: 5)
-3. Error that can't be recovered
+## Autonomous mode
+
+If the user wants this to fire on a recurring schedule, invoke `/loop` instead. `/loop` schedules a cron that calls `/autopilot` every ~13 min, with the boundary check baked in.
+
+```
+/autopilot  →  one tick (with boundary check at start)
+/loop       →  /autopilot every ~13 min (heartbeat)
+```
 
 ## Rules
 
-- ONE task at a time
-- Verify before marking passes: true
-- Minimal changes only
-- Check MAP.md before touching code
-- Log to journal when complete
+- One task at a time. Never batch.
+- Always show *why* before executing.
+- Stop after the first tick. Do not chain. Chaining is `/loop`'s job.
+- Endgame tasks always preferred over reactive signals.
+- At every boundary (no current endgame OR all done), reassess via `/endgame` — read inbox/wiki/logs, pick the next horizon, do not just run forever.
+- If a tick fails, halt and journal the failure. Do not pretend it worked.
+- The CLI writes the heartbeat Notes block. Do not hand-write tick summaries to the journal.

package/atris/skills/endgame/SKILL.md

@@ -0,0 +1,179 @@
+---
+name: endgame
+description: "Backward partner to /flow. Picks the next horizon from inbox + wiki + lessons, writes the reverse path as tagged tasks to TODO.md so /autopilot can pursue it tick by tick. Triggers on: endgame, what's the last move, where are we heading, reverse engineer, work backward."
+version: 1.2.0
+tags: [planning, vision, reverse-engineer, atris, wiki, todo, flow]
+---
+
+> **Sister skill: /flow** — flow runs the same engine in reverse. flow chains forward from identity (who you are → today's next move). endgame chains backward from horizon (where you're going → today's next move). They meet at the same point: the next thing the agent should ship. Use both. Run flow at sunrise to set identity, run endgame at every TODO.md boundary to set horizon, and let /autopilot tick between them.
+
+# /endgame
+
+**Purpose:** help the human (or agent) reach their intent and goal **faster** by leveraging what the wiki already knows. Without endgame, they redo thinking. With endgame, they reach the next move in one pass — and write that move into TODO.md so the autopilot loop can pursue it without re-asking.
+
+Most planning is forward-greedy: *what's the next ticket?* Endgame is backward: *what does winning look like, and what's the shortest path from here?*
+
+> "You can't connect the dots looking forward; you can only connect them looking backward." — Steve Jobs
+
+## Step 0 — CHECK FOR EXISTING ENDGAME FIRST
+
+Before anything else, read `atris/TODO.md`. If it already has a `## Endgame` section AND uncompleted `[endgame]`-tagged tasks in `## Backlog`, **do not pick a new endgame**. Instead reply: "current endgame `<slug>` still active — N steps remaining. Run `/autopilot` to continue, or `force /endgame` to reset." Then exit.
+
+This rule exists so the loop pursues the current horizon to completion instead of constantly repicking.
+
+## Step 1 — READ THE INBOX, WIKI, LOGS
+
+Before picking a new horizon, read what already exists. The wiki + logs are the user's paid-for memory; not using them means they're paying twice.
+
+- `atris/lessons.md` — past surprises and failures the validator wrote down. Read this FIRST. Avoid horizons that hit the same rocks.
+- `atris/wiki/STATUS.md` — current state, last loop findings, suggested next ingests
+- `atris/wiki/index.md` — what pages already exist
+- `atris/wiki/briefs/` — most recent cross-cutting brief pages (often already contain a horizon)
+- `atris/MAP.md` — what code exists today
+- `atris/TODO.md` — what's queued, what's done
+- `atris/logs/YYYY/` — last 7-14 days of journals; scan `## Inbox` sections for unfulfilled ideas (these are user-seeded horizons)
+- `atris/PERSONA.md` — current identity (paired with /flow's forward direction)
+- `atris/business/<slug>/BUSINESS.md` if a business workspace
+
+**Inbox items are the primary horizon source.** If recent journal `## Inbox` sections have unfulfilled ideas, pick the oldest one and run the three moves on it. Only fall back to reactive signals (wiki staleness, broken refs) if the inbox is empty.
+
+If the horizon is genuinely unreadable from those sources, ask **1–3 sharp questions**. Never more. Never a wall of text.
+
+## The three moves
+
+1. **HORIZON** — One paragraph. What does the world look like when we win? Concrete. Falsifiable. Not a slogan.
+2. **REVERSE PATH** — Chain backward from HORIZON. Last move before winning, the one before, etc. **Include eliminate steps** — what gets deleted on the way to the endgame, not just what gets added. Stop when you hit something doable this week. 5–7 links max.
+3. **NEXT MOVE** — The first link in the chain. One concrete action, one session, no hedging.
+
+> **v1.1.0 cut:** prior versions had two more moves — `IDENTITY` ("who are we when we've arrived") and `GAP` ("already true vs not yet"). Identity was philosophical overhead; GAP was just the diff between HORIZON and current state, which the wiki + MAP already give you. Three moves is enough. Less drift surface, faster ticks, fewer phrases for the validator to verify.
+
+## Step 2 — WRITE TO TODO.md
+
+After running the three moves, write the result to `atris/TODO.md`:
+
+1. **Add a `## Endgame` section** (above `## Backlog`) with this exact shape:
+
+```markdown
+## Endgame
+
+**Slug:** <kebab-case-slug>
+**Picked:** YYYY-MM-DD HH:MM
+**Horizon:** <one-line summary of HORIZON>
+**Source:** <inbox-item | wiki-signal | user-prompt> (so we know where it came from)
+```
+
+2. **Add each REVERSE PATH step as a tagged backlog task** in `## Backlog`:
+
+```markdown
+- **T1:** <step 1 description> [endgame]
+- **T2:** <step 2 description> [endgame]
+- **T3:** <step 3 description> [endgame]
+```
+
+The tag must be exactly `[endgame]` (parser only matches `\w+`, no colons or hyphens). The slug lives in the section header.
+
+Use `T1`, `T2`, `T3` … as IDs (or `W1`/`E1`/etc per endgame domain). Single uppercase letter + digits, optional trailing lowercase letter (the parser was extended in commit `4db14d9` to accept `W3b`-style validator sub-task IDs).
+
+3. **Append the full endgame to today's journal `## Notes`** so the reasoning is preserved:
+
+```markdown
+### Endgame picked — HH:MM PDT
+
+slug: <slug>
+source: <where>
+
+HORIZON
+  <one paragraph>
+
+REVERSE PATH
+  ENDGAME
+    ← T5
+    ← T4
+    ← T3
+    ← T2
+    ← T1 (next move)
+
+NEXT MOVE
+  T1: <description>
+  Why this first: <one line>
+```
+
+This is the archive — once the endgame closes, future `/endgame` runs can read this to learn what worked.
+
+## Step 3 — ARCHIVE PRIOR ENDGAME (if any)
+
+If there was a `## Endgame` section in TODO.md before this run AND all its `[endgame]` tasks are done, append a closing entry to today's journal `## Notes`:
+
+```markdown
+### Endgame closed — HH:MM PDT
+
+slug: <prior-slug>
+shipped: N/N steps
+commits: <list of commits since endgame was picked>
+lessons: <one-line takeaway>
+```
+
+Then remove the old `## Endgame` section from TODO.md before writing the new one. Completed `[endgame]` tasks should already have moved to `## Completed` via the validator.
+
+## Output shape (when called interactively)
+
+When a human runs `/endgame` directly (not from a cron tick), show the three moves on screen first, ask one yes/no for confirmation, then write to TODO.md only after the human says go. When called from autopilot at a boundary, skip the confirmation — write straight to TODO.md and journal it.
+
+```
+HORIZON
+  [one paragraph: concrete, falsifiable, not a slogan]
+
+REVERSE PATH
+  ENDGAME
+    ← step N        (add or eliminate)
+    ← step N-1
+    ← ...
+    ← step 1 (this week)
+
+NEXT MOVE
+  [one concrete action, doable in one session]
+  Why this first: [one line]
+```
+
+## Rules
+
+- **Step 0 first.** If a current endgame is still active, do not pick a new one. Continue, don't repick.
+- **Read inbox + wiki first.** The whole point is leveraging what exists.
+- **HORIZON before REVERSE PATH.** Vision before steps.
+- **REVERSE PATH includes eliminate.** Half of strategy is removal. Forward-greedy planning never asks this. Endgame must.
+- **The chain must terminate this week.** If it can't, the horizon is too far — pick a closer one and say so.
+- **5–7 links max in the chain.** More than that = horizon is too vague.
+- **Cite wiki pages** with `[[atris/wiki/...]]` refs.
+- **Ask 1–3 questions max** if the horizon is unclear. Never a wall of text.
+- **One chain, not three.** Pick the shortest defensible one.
+- **No "we could also"** anywhere in NEXT MOVE. There is one move.
+- **Reject mysticism.** Vision is necessary but not sufficient. The chain must be falsifiable and doable.
+- **Tag format is `[endgame]` only** — no colons, no slugs in the tag. Slug lives in the section header.
+
+## Phase 2 — agent runs this on itself
+
+This skill is designed to be runnable by the agent on its own state, not just by humans. When `atris autopilot` finishes the last `[endgame]` task in the current horizon, the next tick's boundary check invokes `/endgame` against the new state, picks the next horizon from inbox/wiki, writes it to TODO.md, and queues the next move — without a human pulling the trigger.
+
+## When to use vs other skills
+
+| Skill | When |
+|---|---|
+| `autopilot` | Run one tick of the current endgame |
+| `decide` | You have N options and need to pick |
+| `improve` | You want to clean up drift |
+| `wiki` | You want to capture knowledge |
+| `loop` | You want the autopilot heartbeat scheduled |
+| **`endgame`** | No current horizon, current one done, or work feels busy-but-pointless |
+
+## Anti-patterns
+
+- Skipping Step 0 (check for existing endgame). Repicking mid-pursuit kills compounding.
+- Skipping Step 1 (read inbox + wiki). The skill is pointless without it.
+- Walls of clarifying questions. Max 1–3.
+- Listing 5 possible endgames. Pick one and commit.
+- REVERSE PATH that's purely additive. Always include at least one eliminate.
+- Chain longer than 7 links. Shorten the horizon.
+- Three "next moves." There is one.
+- Quoting goals from a deck. Read the wiki, look at reality.
+- Tagging tasks with `[endgame:slug]` — parser only accepts `[\w+]`, will fail silently.
+- Padding with IDENTITY or GAP sections — those were cut in v1.1.0 as autopilot overhead.