atris 3.70.0 → 3.71.0

package/README.md

@@ -138,6 +138,24 @@ atris member wake 5
 atris member wake navigator executor
 ```
 
+Wake only picks jobs that have a test to pass, so members know when they are done. Add one like this:
+
+```bash
+atris task new "fix the flaky login test" --verify "node --test test/login.test.js"
+```
+
+Each job gets the time limit set for building in your roster, plus a few minutes for review. To see or change it:
+
+```bash
+atris engine roster
+```
+
+Naming just one member runs one step of work. Add `--keep` to keep that one member working.
+
+```bash
+atris member wake executor --keep
+```
+
 Sleep stops the members that are awake.
 
 ```bash

package/atris/skills/README.md

@@ -34,6 +34,7 @@ cp -r atris/skills/[name] ~/.codex/skills/
 | backend | Backend architecture policy | `policies/atris-backend.md` |
 | blocks | Author Atris block documents: docs, decks, reports | - |
 | calendar | Google Calendar via AtrisOS API | - |
+| campaigns | Run a long goal with a judge that fails today, a budget, and seats | - |
 | commerce | Quote a purchase or stock order; the person approves before anything is charged | - |
 | copy-editor | Detects and fixes AI writing patterns | - |
 | create-app | Build and deploy an Atris app from a description | - |

package/atris/skills/campaigns/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: campaigns
+description: "Run an Atris campaign: a long goal with a judge that fails today, a budget, and members in seats, worked by missions until the judge passes. Use when the goal takes many runs, needs several members, or must spend under a cap. Triggers on: run a campaign, long goal, big goal, keep going until it passes, campaign, judge, budget, atris campaign."
+version: 1.0.0
+tags:
+  - campaign
+  - judge
+  - budget
+  - missions
+  - mcp
+---
+
+# Campaigns
+
+A campaign is a goal plus a judge. The judge is a command that exits 0 only when the goal is met. The campaign runs missions under a budget until the judge passes, the money runs out, or a person has to decide something.
+
+## Campaign or mission
+
+- **Mission**: one member, one objective, one check. Done in a run or a few ticks.
+- **Campaign**: the goal needs many missions, more than one member, or a spending cap. A campaign decides what to do next; its missions do the work.
+
+If one `atris mission start` would finish it, use a mission.
+
+## The five commands
+
+```bash
+atris campaign "<goal>"                      # drafts a judge, proves it fails today, starts on a yes (agents pass --yes; --run keeps going)
+atris campaign run <id> --max-steps 5        # judge, propose missions, run them; stops and says why
+atris campaign show <id>                     # judge reading, money, missions, open asks, next move
+atris campaign answer <id> <ask-id> "<yes>"  # a person answers; agents cannot
+atris campaign sync <id>                     # share it with the Atris web app and iOS
+```
+
+`atris campaign "<goal>"` is the same as `atris campaign new "<goal>"`. Already have a judge? Start directly: `atris campaign "<goal>" --judge "<command>"`. A local campaign needs no budget; one that runs in the cloud does (`--budget 20`). Add `--json` to any verb for machine output. `atris campaign` alone lists every campaign and its next move.
+
+## Write a good judge
+
+1. **Outside the model.** Tests, counts, greps, a build, a local script. Never ask a model whether it is done.
+2. **Fails first.** A judge that passes today is refused: it cannot tell you when the work landed.
+3. **Graded.** Print progress, not just exit status. Lines like `ℹ pass 3` and `ℹ fail 2` become the campaign's answer, so a person sees 3 of 5 instead of "failed".
+4. **Read only and quick.** It runs after every mission. It changes nothing and finishes in minutes.
+
+`atris campaign new` writes the judge to `atris/campaigns/<id>/judge.sh`. Read it before you start; edit it if it checks the wrong thing.
+
+## The no-reload line
+
+Before anything that cannot be undone (sending, paying, deleting, deploying, publishing), stop and ask:
+
+```bash
+atris campaign ask <id> "Deploy the billing change to production?"
+```
+
+The campaign waits. `run` stops with `needs you: 1 open ask`. Only a person closes an ask, in their own terminal. An agent that writes an answer leaves the ask open with a warning.
+
+## From an MCP client
+
+`atris mcp` serves the same verbs as tools: `campaign_list`, `campaign_show`, `campaign_new`, `campaign_start`, `campaign_run` (takes `max_steps`, returns `reason`), `campaign_ask`, `campaign_answer`. Every write is recorded as an agent. `campaign_answer` returns the `person_command` the person runs to close the ask.
+
+## 60-second example
+
+```bash
+atris campaign new "every command in bin/atris.js has a --help that exits 0"
+# draft for: every command ...
+# judge     sh atris/campaigns/cmp-help-everywhere-1a2b/judge.sh
+# today     fails, as it should: pass 41, fail 6
+# start it:  atris campaign start 'Help everywhere' --judge 'sh atris/campaigns/cmp-help-everywhere-1a2b/judge.sh' ...
+atris campaign start 'Help everywhere' --judge 'sh atris/campaigns/cmp-help-everywhere-1a2b/judge.sh' --budget 20 --id cmp-help-everywhere-1a2b
+atris campaign run cmp-help-everywhere-1a2b --max-steps 5
+# stopped after 4 steps: finished
+atris campaign show cmp-help-everywhere-1a2b
+# state     done (judge passed)
+# answer    answered: pass 47, fail 0
+# budget    $6.20 spent of $20.00
+```
+
+## Rules
+
+- No campaign without a judge that fails today.
+- Only the judge or a person finishes a campaign. An agent saying done changes nothing.
+- Every mission reports what it spent. When the budget is gone, the campaign stops.
+- Bound every run with `--max-steps`, then read the stop reason before running again.

package/atris/skills/meta/SKILL.md

@@ -1,24 +1,33 @@
 ---
 name: meta
-description: Metacognition skill for AI agents. Use when starting work, feeling stuck, output feels off, or before complex tasks. Teaches how to think about thinking.
-version: 1.0.0
+description: Metacognition and delegation science skill for AI agents. Use when starting work, coordinating parallel team members, feeling stuck, output feels off, or before complex tasks. Do not use for trivial one-line lookups when the route and fix are already known. Triggers on meta, delegation, coordinate, parallel members, stuck, or self-check.
+version: 1.1.0
 tags:
   - meta
   - metacognition
+  - delegation
+  - coordination
 ---
 
 # Meta Skill
 
-How to be an effective agent. Load this when you need to check yourself.
+How to be an effective agent and coordinator. Load this when you need to check yourself or delegate across a team.
 
 ## When to activate
 
 - Starting a new session (orientation)
+- Delegating work across multiple team members (`atris member run` / `atris member board`)
 - Feeling stuck or uncertain
 - Output feels sloppy or generic
 - Complex task ahead
 - After a mistake
 
+## When NOT to activate
+
+- Single-file mechanical lookups where `atris/MAP.md` already gives the exact line and command
+- Mid-execution of a single bounded test command that is already passing
+- Routine read-only status checks that require no planning or delegation
+
 ## Context awareness
 
 1. **MAP first** - Read `atris/MAP.md` before any search. It's the index.
@@ -35,6 +44,29 @@ How to be an effective agent. Load this when you need to check yourself.
 | Uncertain about intent | Ask ONE question |
 | Output feels off | Pause, re-read context |
 | Stuck > 2 attempts | Escalate, don't spiral |
+| 3+ independent slices | Delegate in parallel to team members |
+
+## The science of delegation
+
+When work spans multiple concerns, shift from solo builder to team coordinator:
+
+1. **Partition by disjoint files** - Assign each member (`builder`, `architect`, `executor`, `auto-improver`, `orb`) a distinct file set so parallel branches never conflict at merge time.
+2. **Bind a scoped, falsifiable check** - Pass an explicit `--verify "node --test test/[scoped].test.js"` that tests only the files the member touches. Never bind a broad suite that mutates or reads shared global state during a parallel run.
+3. **Launch isolated, bounded runs** - Default to a short bounded window (`--minutes 30`) in an isolated repo copy with independent referee review; use multi-hour `--hours` or `--spend-full-budget --detach` only when the operator explicitly asks for a long or overnight run:
+   ```bash
+   atris member run [member] "[objective]" --runner auto --verify "node --test test/[file].test.js" --minutes 30 --ignite
+   ```
+4. **Monitor live telemetry, not guesswork** - Watch `atris member board` and `atris member result [member]`. If a member is `quiet` past its cadence or hits a repeated error streak, inspect its log and restaff or ping it via `atris member ping [member] "[guidance]"`.
+5. **Judge diffs, never prose** - Long runs can omit their final text summary even when all files and tests succeeded. Always verify `git status --short`, `git log -n 3`, and run the scoped test command inside the member's repo copy before marking ready or rejecting.
+6. **Close the loop through review gates** - Move verified work to Review with `atris task ready [id] --proof "[command and exit 0]"` and wait for human acceptance (`atris task accept [id]`) or the owner's explicit `atris autoland` policy before merging onto `origin/master` and running `atris member tidy --dry-run`.
+
+## Safety and failure handling
+
+- **Human approval and landing gate** - Agents prepare proof and move tasks to Review; never run `atris task accept`, never push or merge to `origin/master` without human approval or active owner-enabled `atris autoland`, and never launch multi-hour detached runs unless explicitly requested by the operator.
+- **Protected lanes** - Changes touching auth, billing, session, CSP, security, or production deploy always pause for explicit human review, even when `autoland` is on.
+- **Git hook respect** - If a pre-commit or pre-push hook blocks a commit, stop and fix the root cause. Never bypass hooks with `--no-verify`.
+- **Worktree hygiene** - Never delete a work folder while git locks exist or a process is still active inside it; preview with `atris member tidy --dry-run` before removing merged copies.
+- **Repeated failure breaker** - If a member fails the same check twice in a row, halt that approach, record the cause in `atris/lessons.md`, and restaff with a narrower slice.
 
 ## Self-correction triggers
 
@@ -44,6 +76,7 @@ Stop and reassess when:
 - You're adding features not requested
 - You're explaining instead of doing
 - You've used words like "robust", "comprehensive", "streamlined"
+- Two delegated members are editing the same file
 
 ## Memory leverage
 
@@ -58,6 +91,7 @@ You can stack skills:
 - `meta` + `design` = thoughtful frontend work
 - `meta` + `backend` = careful API design
 - `meta` + `writing` = deliberate prose
+- `meta` + `autopilot` = multi-member parallel execution
 
 Meta is the foundation. Domain skills are the specialization.
 
@@ -66,15 +100,23 @@ Meta is the foundation. Domain skills are the specialization.
 ```
 Orient (read context)
     ↓
-Decide (which skill? what pace?)
+Decide (solo or delegate? which skill? what pace?)
     ↓
-Act (execute with focus)
+Act (execute with focus or dispatch disjoint members)
     ↓
-Check (output match intent?)
+Check (verify diff, scoped tests, and member board)
     ↓
-Learn (add to lessons.md if miss)
+Learn (add to lessons.md if miss, promote to skill at 2-3x)
 ```
 
+## Verification and closure
+
+A solo or delegated task is complete only when all four checks pass with concrete evidence on disk:
+1. The scoped test command (`node --test test/[file].test.js`) is run bare (no pipes) and exits `0`.
+2. `git diff --check` exits `0` with no whitespace errors or conflict markers, and `git status --short` shows only declared files changed.
+3. For delegated runs, `atris member board` shows `done ok` (active or quiet runs are still in progress, never complete) and `atris member result [member] --json` points to a passing receipt in `atris/runs/`.
+4. Any modified skill passes `atris skill audit [name]` with `12/12` (0 errors, 0 warnings) and `atris skill eval atris/skills/[name]/SKILL.md` with `passed: true` and all rubric scores `>= 4`.
+
 ## Anti-patterns
 
 - Grepping before MAP check
@@ -83,6 +125,8 @@ Learn (add to lessons.md if miss)
 - Verbose explanations
 - Guessing instead of asking
 - Repeating past mistakes
+- Delegating overlapping files to parallel workers
+- Judging a run by its prose summary instead of its git diff and test exit code
 - Creating skill without symlinking to .claude/skills/ (won't load mid-session)
 
 ## Skill evolution
@@ -96,4 +140,4 @@ You're training future agents. Leave the codebase smarter than you found it.
 
 ## One-liner
 
-Think before you act. Check yourself. Use the system.
+Think before you act. Partition cleanly when you delegate. Check yourself. Use the system.