atris 3.2.0 → 3.11.0

package/atris/team/validator/MEMBER.md

@@ -47,7 +47,41 @@ tools: []
 
 ## Your Job
 
-After executor finishes:
+You gate the work at **two** points: before it runs (plan-review) and after it runs (review).
+
+### Plan-review — before executor starts
+
+Read the navigator's plan fresh, with no memory of the planning context. Check:
+
+1. **Verify is falsifiable** — points at a rubric or test that can fail at t=0, not `true`, `echo ok`, or similar. Prefer `atris verify <slug> --section <name>`.
+2. **Files declared** — explicit paths, not empty, not vague ("various files").
+3. **Rollback named** — a commit, checkpoint, or `git revert` is enough.
+4. **Plan matches declared fields** — the plan's ASCII/narrative aligns with Files/Exit/Verify.
+5. **No contradictions in lessons.md** — recent failures don't warn against this approach.
+
+Output EXACTLY one of these two formats as the last thing in your response:
+
+```
+SIGNOFF: <one sentence on why the plan is safe>
+```
+
+or
+
+```
+REJECT: <one sentence on what is wrong>
+FIX: <one sentence on what must change>
+PROPOSED:
+  Files: <concrete path list>
+  Exit: <sharp, observable done condition>
+  Verify: <falsifiable shell command, prefer atris verify <slug> --section preflight>
+  Rollback: <git revert <sha> or concrete checkpoint>
+```
+
+Be a drafting partner, not just a critic. When you REJECT, write the PROPOSED block as a concrete draft the human can accept as-is, edit, or reject. Skip any PROPOSED field that is already correct in the original task. Omit the whole PROPOSED block only if the rejection is about scope or intent rather than a field that can be drafted.
+
+No preamble, no explanation before the verdict. The autopilot parses this literally.
+
+### Review — after executor finishes
 
 1. **Ultrathink** — Think 3x: Does this match build.md? Edge cases? Breaking changes?
 2. **Run tests** — All tests must pass

package/atris.md

@@ -1,250 +1,190 @@
-# atris.md
+# atris
 
-> Drop this file anywhere. AI agent team activates.
+Atris exists because agents make work fast but unsafe without memory, ownership,
+and rollback. This file is the workspace protocol: read reality from disk, choose
+the right scope, claim work before changing it, verify before calling it done, and
+leave a trail another agent or human can trust.
 
----
-
-## ACTIVATE
+## activate
 
-**STOP. When you read this or hear "atris activate", do this immediately:**
+On session start, before responding:
 
-1. Load context (ONE time, remember for session):
-   - `atris/logs/YYYY/YYYY-MM-DD.md` (today's journal)
-   - `atris/MAP.md` (navigation overview)
-   - `atris/team/*.md` (all agent specs)
+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
 
-2. Output this EXACT box:
+2. Show this box, then ask what to work on if no task was already given.
 
 ```
 ┌─────────────────────────────────────────────────────────────┐
-│ ATRIS                                            [STAGE]    │
+│ atris                                              [stage]  │
 ├─────────────────────────────────────────────────────────────┤
-│ RECENT                                                      │
-│ • [2-3 items from Completed ✅]                             │
+│ recent                                                      │
+│ • [2-3 items from Completed]                                │
 ├─────────────────────────────────────────────────────────────┤
-│ NOW                                                         │
-│ ► [from In Progress 🔄] ····················· [in progress] │
+│ now                                                         │
+│ ► [from In Progress] ····················· [in progress]    │
 │   [from Backlog] ····························── [next]      │
 ├─────────────────────────────────────────────────────────────┤
-│ INBOX ([count])                                             │
-│ • [from Inbox section]                                      │
+│ inbox ([count])                                             │
+│ • [from Inbox]                                              │
 └─────────────────────────────────────────────────────────────┘
-
-Stage: PLAN → do → review   (capitalize current stage)
 ```
 
-3. Then ask: "What would you like to work on?"
+If a task was already given, show the box and proceed with that task.
 
-**DO NOT explain. DO NOT summarize. Output the box, then ask.**
+## operating rules
 
----
+You can move fast. You do not get to move blindly.
 
-## NEXT
+Before changing anything, state:
+- the goal
+- the files or systems in scope
+- what "done" means
+- how it will be checked
+- what happens if it fails
 
-**STOP. When you hear "atris next", do this immediately:**
+Then:
+- do not execute if another agent owns the same task or files
+- 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
 
-1. Read today's journal
+If you cannot honor these rules, stop, write why in the journal, and ask the human before continuing.
 
-2. Check state and progress through stages:
+Labels used below:
+- `guarded` — checked by code or a pre-commit hook; bypassing is a bug
+- `expected` — convention; honor it or stop
 
-   **No task in progress?**
-   - If Backlog has task → move to In Progress, stage = PLAN
-   - Else if Inbox has items → ask "Convert [item] to task?"
-   - Else → go to BRAINSTORM
+## task shape
 
-   **Task in progress?** Progress to next stage:
-   - **PLAN** → Show ASCII plan, wait for approval → next stage = DO
-   - **DO** → Execute the work → next stage = REVIEW
-   - **REVIEW** → Run validator checks (test, verify, quality check)
-     - If passes → move to Completed, show DONE
-     - If fails → show issues, stay in DO
-
-3. Output this EXACT box:
+Every task in `TODO.md`:
 
 ```
-┌─────────────────────────────────────────────────────────────┐
-│ NEXT: [task name]                              [PLAN|DO|REVIEW]
-│                                                             │
-│ [1-2 sentences: what you'll do in this stage]               │
-└─────────────────────────────────────────────────────────────┘
+- **T#:** <title> [tier] [kind]
+  **Owner:** <slug>
+  **Files:** <paths touched>
+  **Exit:** <observable done condition>
+  **Verify:** <shell command, exits 0 on success>
+  **After:** <T# deps or none>
+  **Rollback:** <commit/checkpoint or "none (gray)">
 ```
 
-4. Wait for input. User says anything → execute current stage → update journal.
+| Field | Meaning | Enforcement |
+|---|---|---|
+| tier | `agent` proceeds, `gray` queues for approval, `human` never attempted by you | guarded |
+| kind | `explore` for ambiguous, `execute` for precise | expected |
+| Files | declared upfront; becomes the file lock | guarded (Swarlo claim) |
+| Verify | must exit 0 for the task to be complete | guarded (tick halts if missing) |
+| Rollback | how to undo; `git revert <sha>` for most tasks | expected |
 
-5. After REVIEW passes, show:
+Deeper project work uses `atris/features/<slug>/` with `idea.md` (plan), `build.md` (steps), `validate.md` (checks). The task points at the triptych; the triptych holds the long form.
 
-```
-┌─────────────────────────────────────────────────────────────┐
-│ DONE: [task name]                                   [✓ REVIEWED] │
-│                                                             │
-│ [1-2 sentences: what was done + review result]              │
-└─────────────────────────────────────────────────────────────┘
-```
+Verify cannot be a raw shell shortcut; it must call a rubric or test that can fail before the work is done. Prefer `atris verify <slug> --section <name>`, which extracts the fenced bash under `## <name>` in `validate.md` and runs it. The rubric is read-only, deterministic, and references only the working tree.
 
-**Every task goes through PLAN → DO → REVIEW. No shortcuts.**
+## routing
 
----
+Before picking up work, decide scope:
+- single project → route to that project's `atris/team/` and `TODO.md`
+- crosses projects → route to `atris/team/cross-project-architect/` and plan the dependency order first
 
-## WORKFLOW
+The human is the constructor. You multiply. Handoff fidelity lives in the files, not in context.
 
-```
-scout → plan → do → review
-```
-
-- **SCOUT** — Read relevant files first. Understand before you act. Report what you found.
-- **PLAN** — ASCII visualization, get approval, NO code yet
-- **DO** — Execute step-by-step, update journal
-- **REVIEW** — Test, validate, clean up, delete completed tasks
-
----
-
-## TASK RULES
-
-Every task must follow these rules. No exceptions.
+## next
 
-**One job per task.** If a task touches more than 2-3 files, break it down. If you can't describe "done" in one sentence, it's too big.
-
-**Clear exit condition.** Every task states what "done" looks like. Not "improve auth" — instead: "Add session check to upload handler. Done when: unauthenticated requests return 401 and test passes."
-
-**Tag every task:**
-- `[explore]` — Ambiguous. Needs reading, research, judgment. Output is understanding.
-- `[execute]` — Precise. Route is clear. Just do it. Output is code or artifact.
-
-**Explore before execute.** When starting a new area of work, the first tasks should be `[explore]`. Read the files. Map the space. Report what you found. Then plan `[execute]` tasks based on what you learned.
-
-**Sequence matters.** Order tasks so each one builds context for the next. Early tasks should teach you about the problem. Later tasks use that knowledge.
-
----
+Move one task at a time through plan → do → review.
 
-## AGENTS
+- **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 (move it to In Progress with `Claimed by:` and a timestamp), execute step by step, update `MAP.md` and the journal as reality changes.
+- **review** — run the task's `Verify:` command, read the diff, run the relevant tests, append a one-line lesson to `lessons.md`, move the task to Completed.
 
-| Command | Agent | Guardrail |
-|---------|-------|-----------|
-| `atris plan` | navigator | Plans only, NO code |
-| `atris do` | executor | Builds only, NO unplanned work |
-| `atris review` | validator | Checks only, NO new features |
-| `atris brainstorm` | brainstormer | Ideas only, NO code |
-
-`atris next` = auto-selects agent based on journal state
-
-Specs loaded at activate from `team/*.md`
-
----
-
-## BRAINSTORM
-
-**When queue empty (no backlog, no inbox):**
+State the next stage:
 
 ```
 ┌─────────────────────────────────────────────────────────────┐
-│ BRAINSTORM                                           [PLAN] │
-├─────────────────────────────────────────────────────────────┤
-│ [1 sentence: what this project is]                          │
-│                                                             │
-│ Ideas:                                                      │
-│ 1. [suggestion based on MAP.md]                             │
-│ 2. [suggestion based on journal patterns]                   │
-│ 3. [suggestion based on product gaps]                       │
-├─────────────────────────────────────────────────────────────┤
-│ Pick one, remix, or "something else"                        │
+│ next: [task]                                  [plan|do|review]
+│ [1-2 sentences on this stage]                               │
 └─────────────────────────────────────────────────────────────┘
 ```
 
-**NO extra reads. Use loaded context. 3 ideas max.**
-
----
+If the queue is empty, suggest three ideas from `MAP.md`, the journal, or product gaps. No extra reads. Three max.
 
-## INDEX
+## sweep
 
-| File | Purpose |
-|------|---------|
-| `MAP.md` | Where is X? (navigation) |
-| `TODO.md` | Task queue (target: 0) |
-| `logs/YYYY/MM-DD.md` | Journal (daily) |
-| `PERSONA.md` | Communication style |
-| `team/` | Agent behaviors |
-| `atrisDev.md` | Full spec (reference) |
+Periodically, and before closing an endgame, clean:
+- stale tasks (claimed >3 days, never finished)
+- broken `MAP.md` refs (auto-heal where possible, flag the rest)
+- stale wiki pages (source newer than `last_compiled`)
+- orphan pages (unlinked from anywhere)
+- empty placeholder sections
 
----
+`atris clean` runs this. `atris clean --dry-run` previews.
 
-## JOURNAL FORMAT
+## journal
 
 ```
-## Completed ✅
-- **C1:** Description [✓ REVIEWED]
+## Completed
+- **C1:** Description [reviewed]
 
-## In Progress 🔄
+## In Progress
 - **T1:** Description
-  **Stage:** PLAN | DO | REVIEW
-  **Claimed by:** [Name] at [Time]
+  **Stage:** plan | do | review
+  **Claimed by:** <agent> at <ISO timestamp>
 
 ## Backlog
 - **T2:** Description
 
 ## Inbox
 - **I1:** Description
-```
 
----
-
-## PERSISTENCE
-
-Context window = cache. Disk = truth. Route discoveries as they happen.
-
-| You discover...     | Write to...          | Format               |
-|---------------------|----------------------|----------------------|
-| Code location       | MAP.md               | file:line reference  |
-| New task            | TODO.md              | Task + exit condition |
-| Decision / tradeoff | Journal → Notes      | Timestamped line     |
-| Something learned   | lessons.md           | One-line lesson      |
-| Work finished       | Journal → Completed  | C#: description      |
-| Source changed       | Re-check referencing pages | Frontmatter: last_compiled |
-
-Don't batch. Don't wait for session end. Nothing important should live only in-context.
-
----
+## Notes
+[timestamped lines — one per discovery, decision, or tick]
+```
 
-## KNOWLEDGE COMPILATION
+Context is a cache. Disk is truth. Route discoveries as they happen:
 
-The workspace is a knowledge compiler. Raw sources in, structured understanding out.
+| You discover... | Write to... |
+|---|---|
+| a code location | `MAP.md` (file:line) |
+| a new task | `TODO.md` |
+| a decision or tradeoff | journal `## Notes` |
+| something learned | `lessons.md` (one line) |
+| work finished | journal `## Completed` (C#) |
+| a source changed | re-check pages that reference it |
 
-**Every markdown page that summarizes or references other files MUST have frontmatter:**
+Do not batch. Nothing important should live only in memory.
 
-```yaml
----
-last_compiled: YYYY-MM-DD
-sources:
-  - path/to/source1
-  - path/to/source2
----
-```
+## failure smells
 
-**Staleness rule:** If any source file was modified after `last_compiled`, the page is stale. On review, re-read the source and update the page. Update `last_compiled` when done.
+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
 
-**What counts as a source:** Any file a page summarizes, references, or draws conclusions from. Code files for MAP.md. Documents for wiki pages. Meeting notes for decision pages.
+Each has real examples in `lessons.md`. Before nontrivial execution, read the relevant recent lessons.
 
-**Compounding:** When you answer a question that required synthesis across multiple pages, file the answer back as a new page (or update an existing one). Explorations accumulate — they don't disappear.
+## upkeep
 
-**Activation:** On session start, if `atris/wiki/STATUS.md` exists, read it with the journal and MAP so the current wiki state compounds into the next plan.
+Pages that summarize or reference other files declare their sources in YAML frontmatter:
 
-**Linting:** During `atris review`, check for:
-- Stale pages (source newer than last_compiled)
-- Orphan pages (no inbound references)
-- Contradictions between pages
-- Concepts mentioned but lacking their own page
+    ---
+    last_compiled: YYYY-MM-DD
+    sources:
+      - path/to/source1
+      - path/to/source2
+    ---
 
----
+If any source was modified after `last_compiled`, the page is stale. Re-read the sources, update the page, bump `last_compiled`.
 
-## RULES
+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.
 
-- 3-4 sentences max
-- ASCII visualization before any plan
-- Check MAP.md before touching code
-- Update journal after completing work
-- Delete tasks when done (target: 0)
-- Persist as you go (see PERSISTENCE)
-- After any file change, flag wiki pages that reference it as stale
+Linting during review catches stale pages, orphans, contradictions, and concepts mentioned but missing their own page.
 
 ---
 
-*Full spec and setup instructions: atrisDev.md*
+*Canonical copy: workspace root `atris.md`. Project copies are distributed; `atris update` syncs them. Full spec: `atrisDev.md`.*

package/bin/atris.js

@@ -199,7 +199,7 @@ function consoleCmd() {
 function showHelp() {
   console.log('');
   console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-  console.log('atrisDev — The new way to build with AI');
+  console.log('atris — an operating system for intelligence');
   console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
   console.log('');
   console.log('Quick Start:');
@@ -273,6 +273,7 @@ function showHelp() {
   console.log('');
   console.log('Business:');
   console.log('  business init <name>   - Create canonical business workspace (cloud + local)');
+  console.log('  business onboard       - Onboard from sparse input (--name, --website, --contact)');
   console.log('  business add <slug>    - Connect a business');
   console.log('  business list          - Show connected businesses');
   console.log('  business remove <slug> - Disconnect a business');
@@ -289,6 +290,7 @@ function showHelp() {
   console.log('  cr --all               - Audit all backend services');
   console.log('');
   console.log('Cloud & agents:');
+  console.log('  computer   - Talk directly to the AI computer (bash or agent exec)');
   console.log('  console    - Start/attach always-on coding console (tmux daemon)');
   console.log('  agent      - Select which Atris agent to use');
   console.log('  chat       - Chat with the selected Atris agent');
@@ -416,7 +418,7 @@ if (command === 'help' || command === '--help' || command === '-h') {
 
 // Core command handlers — loaded eagerly (used by interactiveEntry default path)
 const { initAtris: initCmd } = require('../commands/init');
-const { syncAtris: syncCmd } = require('../commands/sync');
+const { syncAtris: syncCmd, syncAtrisAll: syncAllCmd } = require('../commands/sync');
 const { logAtris: logCmd } = require('../commands/log');
 const { activateAtris: activateCmd } = require('../commands/activate');
 const { statusAtris: statusCmd } = require('../commands/status');
@@ -427,7 +429,7 @@ const { planAtris: planCmd, doAtris: doCmd, reviewAtris: reviewCmd } = require('
 // Check if this is a known command or natural language input
 const knownCommands = ['init', 'log', 'status', 'analytics', 'visualize', 'brainstorm', 'autopilot', 'run', 'plan', 'do', 'review', 'release',
                        'activate', '_activate', 'agent', 'chat', 'console', 'login', 'logout', 'whoami', 'switch', 'use', 'accounts', '_resolve', '_profile-email', '_switch-session', 'shell-init', 'update', 'upgrade', 'version', 'help', 'next', 'atris',
-                       'clean', 'verify', 'search', 'skill', 'member', 'learn', 'plugin', 'experiments', 'pull', 'push', 'align', 'terminal', 'diff', 'business', 'sync',
+                       'clean', 'verify', 'search', 'skill', 'member', 'app', 'learn', 'plugin', 'experiments', 'pull', 'push', 'align', 'terminal', 'computer', 'diff', 'business', 'sync',
                        'ingest', 'query', 'lint', 'loop',
                        'gmail', 'calendar', 'twitter', 'slack', 'integrations', 'setup', 'clean-workspace', 'cw',
                        'fork', 'browse', 'publish', 'sleep', 'wake', 'feedback', 'wiki', 'code-review', 'cr', 'soul', 'fleet'];
@@ -796,7 +798,15 @@ if (command === 'init') {
 } else if (command === 'activate') {
   activateCmd();
 } else if (command === 'update' || command === 'sync') {
-  syncCmd();
+  if (process.argv.includes('--all')) {
+    const dryRun = process.argv.includes('--dry-run');
+    const force = process.argv.includes('--force') || process.argv.includes('--yes') || process.argv.includes('-y');
+    Promise.resolve(syncAllCmd({ dryRun, force }))
+      .then(() => process.exit(0))
+      .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
+  } else {
+    syncCmd();
+  }
 } else if (command === 'upgrade') {
   upgradeAtris().then(() => process.exit(0)).catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
 } else if (command === 'chat') {
@@ -1001,6 +1011,13 @@ if (command === 'init') {
   const dryRun = process.argv.includes('--dry-run') || process.argv.includes('-n');
   require('../commands/clean').cleanAtris({ dryRun });
 } else if (command === 'verify') {
+  const sectionIdx = process.argv.indexOf('--section');
+  if (sectionIdx > 0 && process.argv[sectionIdx + 1]) {
+    const slug = process.argv[3] && !process.argv[3].startsWith('--') ? process.argv[3] : null;
+    const section = process.argv[sectionIdx + 1];
+    const code = require('../commands/verify').verifyRubric(slug, section);
+    process.exit(code);
+  }
   const taskId = process.argv[3] || null;
   require('../commands/verify').verifyAtris(taskId);
 } else if (command === 'release') {
@@ -1056,6 +1073,10 @@ if (command === 'init') {
   const subcommand = process.argv[3];
   const args = process.argv.slice(4);
   require('../commands/member').memberCommand(subcommand, ...args);
+} else if (command === 'app') {
+  const subcommand = process.argv[3];
+  const args = process.argv.slice(4);
+  require('../commands/app').appCommand(subcommand, ...args);
 } else if (command === 'pull') {
   require('../commands/pull').pullAtris()
     .then(() => process.exit(0))
@@ -1072,6 +1093,10 @@ if (command === 'init') {
   require('../commands/terminal').terminalAtris()
     .then(() => process.exit(0))
     .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
+} else if (command === 'computer') {
+  require('../commands/computer').runComputer()
+    .then(() => process.exit(0))
+    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
 } else if (command === 'diff') {
   let diffSlug = process.argv[3];
   if (!diffSlug || diffSlug.startsWith('-')) {
@@ -1238,13 +1263,17 @@ async function agentAtris() {
     process.exit(1);
   }
 
-  // Check if logged in
-  const credentials = loadCredentials();
-
-  if (!credentials || !credentials.token) {
+  // Check if logged in (with token refresh)
+  const ensured = await ensureValidCredentials();
+  if (ensured.error === 'not_logged_in' || !ensured.credentials?.token) {
     console.error('✗ Error: Not logged in. Run "atris login" first.');
     process.exit(1);
   }
+  if (ensured.error) {
+    console.error(`✗ Error: Authentication failed: ${ensured.detail || ensured.error}. Run "atris login" to re-authenticate.`);
+    process.exit(1);
+  }
+  const credentials = ensured.credentials;
 
   console.log('🔍 Fetching your agents...\n');
 
@@ -1331,12 +1360,17 @@ async function chatAtris() {
     process.exit(1);
   }
 
-  // Check credentials
-  const credentials = loadCredentials();
-  if (!credentials || !credentials.token) {
+  // Check credentials (with token refresh)
+  const ensured = await ensureValidCredentials();
+  if (ensured.error === 'not_logged_in' || !ensured.credentials?.token) {
     console.error('✗ Error: Not logged in. Run "atris login" first.');
     process.exit(1);
   }
+  if (ensured.error) {
+    console.error(`✗ Error: Authentication failed: ${ensured.detail || ensured.error}. Run "atris login" to re-authenticate.`);
+    process.exit(1);
+  }
+  const credentials = ensured.credentials;
 
   // If message provided, one-shot mode
   if (message) {
@@ -1542,7 +1576,7 @@ async function atrisDevEntry(userInput = null) {
   }
 
   console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-  console.log('🤖 atrisDev Protocol — Navigator Agent');
+  console.log('atris — navigator agent');
   console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
   console.log('');