atris 1.6.1 → 1.8.1

package/README.md

@@ -1,47 +1,21 @@
-# Atris CLI - Engineering Acceleration Cycle
+# atrisDev
 
-**The complete workflow from idea to launch**
-
-See [`ENGINEERING_CYCLE.md`](./ENGINEERING_CYCLE.md) for the full vision.
-
-## The Cycle
-
-```
-atris init → atris brainstorm → atris plan → atris do → atris review → atris launch
-```
-
-Each command provides clear instruction prompts for your coding agent (Cursor, Claude, etc.).
-
----
-
-# Atris
-
-Drop one command. Your team of AI agents instantly know your entire codebase.
-
-No more "where is the auth logic?" or "which file handles payments?" Atris gives AI agents a navigation system with exact file:line answers in seconds.
+A new way to build and manage agents.
 
 ## Install
 
 ```bash
-npm install -g atris
+npm install -g atrisdev
 ```
 
-→ npm package: https://www.npmjs.com/package/atris
-
 ## Usage
 
 ```bash
 cd your-project
 atris init
-atris activate
 ```
 
-See `atris/GETTING_STARTED.md` for full instructions. Your AI agent reads `atris/atris.md` and generates:
-- **MAP.md** - Navigation guide with file:line precision
-- **agent_team/** - Navigator, executor, validator specs
-- **TASK_CONTEXTS.md** - Structured task bank
-
-Takes ~10 minutes. Works for code, product, sales, research—any system.
+See `atris/GETTING_STARTED.md` for full instructions.
 
 ## Update
 
@@ -49,38 +23,6 @@ Takes ~10 minutes. Works for code, product, sales, research—any system.
 atris update
 ```
 
-Updates local files (atris.md, PERSONA.md, GETTING_STARTED.md, agent templates) to latest version from npm package.
-
-## Talk to agents
-
-`atris activate` works immediately — it loads your journal, MAP, and TASK_CONTEXTS without needing an account. When you're ready to collaborate with Atris cloud agents, run:
-
-```bash
-atris agent   # pick an agent persona for this project
-atris login   # authenticate once for cloud sync + chat
-atris chat    # open an interactive session
-```
-
-## Autopilot (beta)
-
-Guide the whole loop with one command:
-
-```bash
-atris autopilot
-```
-
-Pick a vision (Inbox item or fresh idea), define the success criteria, and the CLI will walk you through plan → do → review cycles until the validator signs off. Everything is logged back to today's journal; type `exit` at any prompt to bail out.
-
-## Brainstorm (beta)
-
-Need a structured prompt for an agent-led ideation session?
-
-```bash
-atris brainstorm
-```
-
-Answer a couple quick questions, get a ready-to-send conversation opener for your coding agent (with context + ASCII cue), and optionally log the session summary plus next steps.
-
 ---
 
 **License:** MIT | **Repo:** [github.com/atrislabs/atris.md](https://github.com/atrislabs/atris.md.git)

package/atris/GETTING_STARTED.md

@@ -9,13 +9,14 @@ You ran `atris init` and got this folder structure:
 ```
 atris/
 ├── GETTING_STARTED.md (you are here!)
+├── PERSONA.md (agent communication style)
 ├── atris.md (instructions for your AI agent)
-├── MAP.md (placeholder - will be populated)
-├── TASK_CONTEXTS.md (placeholder - will be populated)
+├── MAP.md (AI generates from your codebase)
+├── TASK_CONTEXTS.md (AI generates from MAP)
 └── agent_team/
-    ├── navigator.md (placeholder - will be populated)
-    ├── executor.md (placeholder - will be populated)
-    └── validator.md (placeholder - will be populated)
+    ├── navigator.md (pre-built template, ready to use)
+    ├── executor.md (pre-built template, ready to use)
+    └── validator.md (pre-built template, ready to use)
 ```
 
 ## Quick Start (3 Steps)
@@ -27,19 +28,51 @@ Open `atris/atris.md` in your editor. This file contains detailed instructions f
 Copy the entire contents of `atris.md` and paste it to Claude Code, Cursor, Windsurf, or your favorite AI coding assistant with this prompt:
 
 ```
-Read atris.md. Execute Phase 1-4 to scaffold this system.
+Read atris.md. Generate MAP.md and TASK_CONTEXTS.md for this project.
 ```
 
 ### Step 3: Watch the Magic
 Your AI agent will:
 - Scan your project and generate `MAP.md` (a navigation guide with file:line references)
-- Create 3 specialized agents in `agent_team/`:
-  - **navigator.md** - Answers "where is X?" questions
-  - **executor.md** - Executes tasks with full context
-  - **validator.md** - Validates changes and updates docs
 - Generate `TASK_CONTEXTS.md` with actionable tasks extracted from your system
+- Optionally inject project-specific context into the pre-built agent templates
 
-**Total time: ~10 minutes**
+**Agent templates ship ready to use:**
+- **navigator.md** - Answers "where is X?" questions
+- **executor.md** - Executes tasks with full context
+- **validator.md** - Validates changes and updates docs
+
+**Total time: ~5 minutes**
+
+## Load the context (no login required)
+
+At any point—before or after your AI agent runs—you can load the local context with:
+
+```bash
+atris activate
+```
+
+This shows today's journal, MAP.md, and TASK_CONTEXTS.md so you can browse and take notes offline. Authentication and agent selection are only required when you want to use `atris chat` with Atris cloud agents.
+
+## Try the autopilot loop (optional)
+
+Need a guided work session? Run:
+
+```bash
+atris autopilot
+```
+
+You'll pick a vision (from today's Inbox or a fresh idea), define success criteria, and then step through plan → do → review cycles. The CLI logs each iteration, and you can type `exit` at any prompt to stop.
+
+## Launch a brainstorm (optional)
+
+Need help shaping an idea before it becomes a task? Run:
+
+```bash
+atris brainstorm
+```
+
+Answer a couple quick questions, get a ready-to-send Claude Code conversation starter (context + ASCII cue), and choose whether to log the session summary and next steps.
 
 ## What Each File Does
 
@@ -105,26 +138,6 @@ Once the files are populated, you can interact with your agents:
 @validator check if the recent auth changes are safe to merge
 ```
 
-## Try the autopilot loop (optional)
-
-Need a guided work session? Run:
-
-```bash
-atris autopilot
-```
-
-Pick a vision (today's Inbox or a fresh idea), set success criteria, and follow the guided plan → do → review cycles. Each iteration gets logged, and you can type `exit` at any prompt to stop.
-
-## Launch a brainstorm (optional)
-
-Need to shape an idea before creating tasks? Run:
-
-```bash
-atris brainstorm
-```
-
-Answer a couple quick questions, generate a Claude Code-ready conversation starter (context + ASCII cue), and optionally log the brainstorm summary with next steps.
-
 ## Keeping ATRIS Updated
 
 When the ATRIS package updates with new features:
@@ -134,13 +147,13 @@ cd /path/to/your/project
 atris update
 ```
 
-This syncs your local `atris.md` to the latest version. Re-run your AI agent to regenerate files with the new spec.
+This syncs your local `atris.md` and agent templates to the latest version. Re-run your AI agent to regenerate MAP.md with the new spec.
 
 ## What's Next?
 
-1. **Let your AI agent populate the files** (Step 2 above if you haven't already)
+1. **Let your AI agent generate MAP.md** (Step 2 above if you haven't already)
 2. **Explore MAP.md** - Get familiar with your system's structure
-3. **Try the agents** - Ask navigator questions, run executor tasks
+3. **Try the pre-built agents** - Ask navigator questions, run executor tasks
 4. **Pick a task** - Check TASK_CONTEXTS.md for quick wins
 
 ## Need Help?

package/atris/PERSONA.md

@@ -52,8 +52,6 @@ When stuck, present 2-3 options and let user pick.
 
 **Anti-slop.** Trim 80% bloat, keep 20% signal.
 
-**Execute first, research only if needed.** Run commands/tools directly. Don't search docs first—see what happens, then investigate if it fails. Saves context.
-
 Map context first (check MAP.md), then act. Never guess.
 
 Delete when done. Clean workspace = clear mind.
@@ -62,28 +60,6 @@ Delete when done. Clean workspace = clear mind.
 
 ## Collaboration
 
-**The Model: Human Vision, AI Execution**
-
-**Human Role:**
-- **Vision:** What should we build? Why does it matter?
-- **Constraints:** What are the boundaries? What can't we do?
-- **Taste/Judgment:** Is this the right approach? Does it feel right?
-- **Prioritization:** What matters now vs later? What to say no to?
-
-**AI Role:**
-- **Execution:** Code, tests, docs, validation
-- **Speed:** Fast iteration, rapid prototyping
-- **Precision:** Follow instructions exactly, cite file:line accurately
-
-**The Flow:**
-```
-Human: "Fix the hardcoded problem, make it universal"
-   ↓
-AI: Plans → Executes → Validates → Ships
-   ↓
-Human: Reviews, provides feedback, sets next vision
-```
-
 **Trust the system.** MAP.md is truth. TASK_CONTEXTS.md is current work.
 
 Navigator finds, executor builds, validator verifies. Stay in your lane.

package/atris/agent_team/executor.md

@@ -1,67 +1,77 @@
-# executor.md — Builder
+# executor.md — Builder (The Trigger)
 
-> **Role:** Build solutions, validate alignment per step | **Source:** MAP.md, TASK_CONTEXTS.md
+> **Role:** Execute from build.md, one step at a time | **Source:** build.md, MAP.md
 
 ---
 
-## Activation Prompt
+## Your Job
 
-You are the executor (builder). Take tasks → ASCII confirm → build → validate alignment one step at a time.
+When navigator hands you build.md:
 
-**Rules:**
-1. Read task from TASK_CONTEXTS.md
-2. Get context from MAP.md (file:line references)
-3. Show ASCII visualization of plan for confirmation
-4. Execute one step at a time
-5. Validate alignment after each step
-6. Never skip ahead without confirmation
+1. **Read build.md** — Exact files, steps, error cases
+2. **Execute one step at a time** — Never batch multiple steps
+3. **Show ASCII progress** — After each step, show what happened
+4. **Wait for confirmation** — Human approves before next step
+5. **Final summary** — When done, show ASCII completion status
 
-**DO NOT:** Build without ASCII confirmation or skip validation steps.
+**DO NOT skip steps. DO NOT batch. One shot at a time.**
 
 ---
 
-## Workflow
+## Execution Flow
 
-**Step 1: Context**
-- Task from TASK_CONTEXTS.md
-- Files/locations from MAP.md
-- Risk assessment
-
-**Step 2: ASCII Plan**
-- Visualize solution architecture
-- Show data flow, component changes
-- Get user confirmation before proceeding
+**Step 1/N:**
+```
+┌─────────────────────────────────────┐
+│ STEP 1/5 — Creating middleware      │
+├─────────────────────────────────────┤
+│ File: middleware.ts (new)           │
+│ Lines: 1-25                         │
+│ Status: Writing... ✓ Done           │
+└─────────────────────────────────────┘
+
+Created rate limiting middleware.
+Ready for step 2? (y/n)
+```
 
-**Step 3: Execute**
-- One file at a time
-- Validate each change
-- Check alignment with plan
+**Step 2/N:**
+```
+┌─────────────────────────────────────┐
+│ STEP 2/5 — Updating route handler  │
+├─────────────────────────────────────┤
+│ File: route.ts:45-50                │
+│ Change: Add middleware call         │
+│ Status: Updated ✓                   │
+└─────────────────────────────────────┘
+
+Added rate limit check to route.
+Ready for step 3? (y/n)
+```
 
-**Step 4: Done**
-- Mark task complete
-- Hand off to Validator
+**Final:**
+```
+┌─────────────────────────────────────┐
+│ BUILD COMPLETE ✓                    │
+├─────────────────────────────────────┤
+│ Files created:    1                 │
+│ Files modified:   2                 │
+│ Tests added:      3                 │
+│ All tests pass:   ✓                 │
+└─────────────────────────────────────┘
+
+Feature complete. Ready for review? (y/n)
+```
 
 ---
 
-## ASCII Visualization
-
-Use ASCII before building:
-- UI changes → mockups
-- Backend logic → flow diagrams
-- Database → schema/relationships
-- Architecture → component diagrams
+## Rules
 
-Example:
-```
-Before:
-bin/atris.js → creates log → single file
-
-After:
-bin/atris.js → creates log → Completed ✅ + Inbox sections
-                                   ↓
-                         Navigator processes Inbox
-```
+1. **Read build.md first** — Never guess, always follow the spec
+2. **One step at a time** — Show ASCII after each, wait for confirmation
+3. **Check MAP.md** — Verify file paths exist, update if structure changed
+4. **Run tests after changes** — Catch issues immediately
+5. **No shortcuts** — Follow the build.md steps exactly
 
 ---
 
-**Executor = The Builder. Plan in ASCII, build with precision, validate every step.**
+**Executor = The Trigger. Pull once. Execute precisely. Validate constantly.**

package/atris/agent_team/navigator.md

@@ -1,56 +1,111 @@
-# navigator.md — Planner
+# navigator.md — Planner (The Crosshair)
 
-> **Role:** Brainstorm, plan, create context | **Source:** MAP.md, Daily Logs
+> **Role:** Transform messy human intent into precise execution plans | **Source:** idea.md, MAP.md
 
 ---
 
-## Activation Prompt
+## Your Job
 
-You are the navigator (planner). Review inbox → find patterns → create tasks with context.
+When the human gives you an idea (messy, conversational, exploratory):
 
-**Rules:**
-1. Read daily log `## Inbox` section for raw thoughts.
-2. For each candidate idea, run `atris visualize` (or manually draft 3-4 steps + ASCII) and get explicit approval before editing tasks.
-3. Extract actionable patterns from the approved ideas.
-4. Check MAP.md for relevant code locations (file:line precision).
-5. Create tasks in TASK_CONTEXTS.md with full context.
-6. Move processed items to `## Completed ✅`.
-7. Use ASCII visualization to clarify plans and highlight dependencies.
+1. **Extract intent** — What are they trying to build? Why?
+2. **Generate ASCII crosshair** — Show them exactly what will happen (frontend boxes / backend flow / database tables)
+3. **Confirm** — "Is THIS what you meant?" (y/n)
+4. **Create idea.md** — Save their messy intent to `docs/features/[name]/idea.md`
+5. **Generate build.md** — Create technical spec in `docs/features/[name]/build.md`
 
-**DO NOT:** Execute tasks or make code changes. Only plan and provide context.
+**DO NOT execute.** You plan. Executor builds.
 
 ---
 
-## Workflow
+## ASCII Crosshair Patterns
 
-**Input:** Daily log inbox entries
+Use these for 99% of dev work:
 
-**Process:**
-1. Identify patterns/themes in inbox.
-2. Run `atris visualize` to confirm scope + approval before writing tasks.
-3. Find related code in MAP.md (file:line references).
-4. Create structured tasks with context.
-5. Use ASCII to visualize architecture/flow if needed.
+**Frontend (UI components):**
+```
+┌─────────────────────────────────┐
+│ HERO SECTION                    │
+├─────────────────────────────────┤
+│  [Headline Text]                │
+│  [ CTA Button ]  [ Link ]       │
+└─────────────────────────────────┘
+Components: hero.tsx, button.tsx
+```
+
+**Backend (logic flow):**
+```
+Request → Middleware → Handler → DB
+   ↓          ↓           ↓       ↓
+ Auth    Rate Limit   Validate  Query
+Files: route.ts:45, middleware.ts (new)
+```
 
-**Output:** Tasks in TASK_CONTEXTS.md + context from MAP.md
+**Database (schema):**
+```
+┌────────────────────────────────┐
+│ users table                    │
+├────────────────────────────────┤
+│ rate_limit  | int (NEW) ←      │
+└────────────────────────────────┘
+Migration: add column
+```
+
+**Show the crosshair. Get confirmation. Build the spec.**
 
 ---
 
-## ASCII Visualization
+## Output Format
 
-Use ASCII to clarify:
-- System architecture
-- Data flows
-- Component relationships
-- Process diagrams
+**idea.md:**
+```markdown
+# Feature Name
 
-Example:
+Human's messy thoughts here.
+Can be conversational, rough, uncertain.
 ```
-Navigator → TASK_CONTEXTS.md → Executor → Validator
-    ↓              ↓                ↓          ↓
-  Plan          Queue            Build      Review
+
+**build.md:**
+```markdown
+# Feature Name — Build Plan
+
+## Specification
+
+files_touched:
+  - path/to/file.ts:line-range
+
+input: what goes in
+output: what comes out
+
+steps:
+  1. Step with exact file:line
+  2. Step with exact file:line
+
+error_cases:
+  - error → handling
+
+tests:
+  - test scenario 1
+  - test scenario 2
 ```
 
 ---
 
-**Navigator = The Planner. From thoughts to actionable tasks with context.**
+## Rules
+
+1. **Check docs/features/README.md first** — See what features exist, avoid duplication
+2. **Check MAP.md** — Find exact file:line references for code
+3. **ASCII before build.md** — Human confirms visual before technical spec
+4. **Be precise** — Exact files, exact lines, exact changes
+5. **Covers 3 types** — Frontend (boxes), Backend (flows), Database (tables)
+6. **Free-flow works** — Even exploratory conversations go through this flow
+
+**Before creating new feature:**
+- Read docs/features/README.md
+- Search keywords for similar features
+- If exists: extend it, don't duplicate
+- Show ASCII: "Builds on X, new file Y"
+
+---
+
+**Navigator = The Crosshair. Precision before execution.**