atris 3.53.0 → 3.56.0

package/FOR_AGENTS.md

@@ -48,6 +48,13 @@ atris task claim <id> --as <your-name>
 atris task ready <id> --proof "command that passed"
 ```
 
+Capture a quick idea without opening the journal REPL:
+
+```bash
+atris log "an idea for later"
+# or headless: atris wish "an idea" --json --no-mission
+```
+
 **Never** `atris task accept` unless a human approved. That's their gate, not yours.
 
 Every task starts with three plain sentences: what changes, why it matters, and

package/README.md

@@ -207,7 +207,7 @@ atris business record atris/reports/2026-04-12-operator-recap.md --outcome mixed
 | `atris run diff` | Compare two run logs side by side |
 | `atris autopilot` | Keep the workspace moving: mission/member legs until `atris autopilot stop` (`--legacy` for the old approval loop) |
 | `atris pulse` | Install or run the durable overnight heartbeat |
-| `atris log` | Add inbox items to today's journal |
+| `atris log "note"` | Add an inbox item to today's journal (`log --repl` for the editor; `wish` for headless intake) |
 | `atris now` | Show the current operating truth |
 | `atris radar` | Show live agents joined with tasks, missions, and worktrees |
 | `atris ctop` | Show process-first live agent CPU and memory |

package/atris/policies/ANTISLOP.md

@@ -4,6 +4,8 @@
 
 This checklist prevents slop by forcing intentionality. Before finalizing ANY output, run through these gates.
 
+The build enforces deterministic prose tells; see `commands/slop.js`. Review only the judgment calls below.
+
 ---
 
 ## The Differentiation Gate
@@ -40,7 +42,6 @@ If you can't answer in one sentence, you're hedging. Pick a direction and commit
 
 ### Punctuation
 - [ ] No sparkles or decorative emoji (✨ 🚀 💡 🎯)
-- [ ] No em dashes (—) unless direct quote or title separator
 - [ ] No ellipsis for drama (...)
 - [ ] No exclamation points unless error/warning
 

package/atris/skills/copy-editor/SKILL.md

@@ -465,8 +465,9 @@ Provide:
 
 Run this check before approving ANY writing. LLMs will violate these rules even when explicitly trying not to.
 
+The build enforces deterministic prose tells; see `commands/slop.js`. Review the judgment-only items below.
+
 ```
-[ ] No em dashes anywhere
 [ ] No rule of three (exactly 3 items in a list or 3 parallel phrases)
 [ ] No negative parallelisms ("didn't X, needed Y" or "not just X, it's Y")
 [ ] No AI vocabulary (crucial, delve, unpack, landscape, pivotal, testament, vibrant, etc.)

package/atris/skills/design/SKILL.md

@@ -141,7 +141,7 @@ This skill compounds or it dies. The contract, every frontend session:
 - WCAG AA contrast (4.5:1 text, 3:1 UI)?
 - works on mobile (44px touch targets, no horizontal scroll, readable text)?
 - respects `prefers-reduced-motion`?
-- zero shout-cased copy? zero em dashes in copy?
+- zero shout-cased copy?
 - did you name the moves in craft vocabulary (vertical rhythm, negative space, bolder/quieter)?
 - did you use anti-attractors (named what to avoid, seeded a reference, set a constraint)?
 - if agent-facing: does it have agentic affordances (clear errors, structured output, stable exit codes)?

package/atris/skills/x-search/SKILL.md

@@ -12,6 +12,19 @@ tags:
 
 > Drop this in `~/.claude/skills/x-search/SKILL.md` and Claude Code becomes your X/Twitter intelligence tool.
 
+## Customer path (preferred)
+
+Logged-in customers should use the CLI. Same auth and billing as `atris youtube process` (5 credits).
+
+```bash
+atris x-search "MCP agents"
+atris x-search "MCP agents" --limit 5 --days 2
+atris x-search person --name "Leah Bonvissuto" --handle leahbon
+atris x-search --help
+```
+
+Add `--json` for the raw API payload. Curl below is the raw API for debugging only.
+
 ## Bootstrap (ALWAYS Run First)
 
 Before any X search operation, run this bootstrap to ensure everything is set up:
@@ -145,19 +158,16 @@ curl -s -X POST "https://api.atris.ai/api/x-search/research-person" \
 ## Workflows
 
 ### "Search X for tweets about a topic"
-1. Run bootstrap
-2. Search: `POST /x-search/search` with `{query, limit}`
-3. Display results: tweet text, author, engagement, links
+1. Prefer `atris x-search "<query>"` (or bootstrap + curl if debugging the API)
+2. Display results: tweet text, citations (x.com links), credits used/remaining
 
 ### "Find tweets from the last week about X"
-1. Run bootstrap
-2. Search with date filter: `POST /x-search/search` with `{query, limit, days_back: 7}`
-3. Display results sorted by engagement
+1. Prefer `atris x-search "<query>" --days 7 --limit 10`
+2. Display results and citations
 
 ### "Research a person before a meeting"
-1. Run bootstrap
-2. Research: `POST /x-search/research-person` with `{name, handle, company, context}`
-3. Display profile, background, talking points
+1. Prefer `atris x-search person --name "..." --handle ... --company ... --context "..."`
+2. Display profile, background, talking points
 
 ### "Monitor keyword clusters for revenue intel"
 1. Run bootstrap
@@ -214,21 +224,13 @@ curl -s -X POST "https://api.atris.ai/api/x-search/research-person" \
 # Setup (one time)
 npm install -g atris && atris login
 
-# Get token
-TOKEN=$(node -e "console.log(require('$HOME/.atris/credentials.json').token)")
-
-# Search tweets
-curl -s -X POST "https://api.atris.ai/api/x-search/search" \
-  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
-  -d '{"query": "AI agents", "limit": 10}'
+# Preferred: CLI
+atris x-search "AI agents" --limit 10 --days 7
+atris x-search person --name "John Doe" --handle johndoe --company Acme
 
-# Search last 7 days only
+# Raw API (debug)
+TOKEN=$(node -e "console.log(require('$HOME/.atris/credentials.json').token)")
 curl -s -X POST "https://api.atris.ai/api/x-search/search" \
   -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
   -d '{"query": "AI agents", "limit": 10, "days_back": 7}'
-
-# Research a person
-curl -s -X POST "https://api.atris.ai/api/x-search/research-person" \
-  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
-  -d '{"name": "John Doe", "handle": "johndoe", "company": "Acme"}'
 ```

package/atris/skills/youtube/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: youtube
-description: "A YouTube link in any message routes here. Run atris youtube notes <url> FIRST: free, about 30 seconds, quotes verified against the transcript. Never summarize a video from model memory, that is fabrication. Use atris youtube process only to store it as queryable knowledge (5 credits). Triggers on: any youtube.com or youtu.be link, youtube, video, watch this, notes on this."
-version: 2.4.0
+description: "YouTube discovery and learning. Use atris youtube search QUERY to get free youtu.be links (local ytsearch/yt-dlp, zero credits). Use atris youtube search --paid QUERY to buy watch permalinks from Atris (5 credits, login required). A YouTube link in any message routes here: run atris youtube notes URL FIRST (free, about 30s, quotes verified). Never summarize a video from model memory. Use atris youtube process only to store it as queryable knowledge (5 credits). Triggers on: youtube search, find videos, paid youtube search, any youtube.com or youtu.be link, youtube, video, watch this, notes on this."
+version: 2.7.0
 tags:
   - youtube
   - research
@@ -11,18 +11,16 @@ tags:
 
 # YouTube Skill
 
-Process any YouTube video through Atris transcript-first analysis. The CLI extracts local captions with timestamps when available, sends that transcript to Atris, and falls back to cloud video processing when captions are unavailable or unusable. 5 credits per video, refunded if processing fails.
+Three rails. Pick before running anything:
 
-## Route first: learning vs product
+- **Search / discovery (free)** → `atris youtube search "<query>"`. Local ytsearch or yt-dlp `ytsearchN:`. Returns title, channel, duration, views, upload_date, and a `youtu.be` link. Zero credits. Use this to *get* video links; do not call process until the user picks one.
+- **Paid search (5 credits)** → `atris youtube search --paid "<query>"`. Posts `/youtube/search` with the stored token or a youtube-scope agent mint. Prints watch permalinks, titles, and credits. Use this when the customer wants to buy permalinks the same way as `atris x-search`. Do not replace free search with this.
+- **Notes / learning (free)** → `atris youtube notes <url>`. Local captions + a fast engine, about 30 seconds, quotes verified against the transcript. Use when the goal is to learn from a video you already have.
+- **Process / product (5 credits)** → `atris youtube process <url>`. Credits-billed cloud knowledge store. Use when a customer/agent needs the video stored as Atris knowledge.
 
-Two rails process YouTube videos: pick before running anything:
+If the user says "find videos", "search youtube", or "get youtube links" → search. If they say "learn from", "notes on", "alpha", or "rabbit hole" → notes. If they say "process", "store", "add to knowledge" → process.
 
-- **Learning / work rail** → use the `alpha-learn` skill (ytnotes). Local yt-dlp + grok, zero credits, podcastnotes-style notes, tweet-feed output, `[claimable]` entries in today's journal for other agents. Use this when the goal is to LEARN from a video or mine it for Atris work.
-  Canonical ytnotes source is `scripts/det/ytnotes` (install: `ln -sf "$PWD/scripts/det/ytnotes" ~/.local/bin/ytnotes`).
-  Runs are scored by `node scripts/det/ytrail-eval.js`.
-- **Product rail** → this skill (`atris youtube process`). Credits-billed, stores knowledge in the Atris backend, customer-facing path. Use this when a customer/agent needs the video stored as Atris knowledge or answered via the API.
-
-If the user says "learn from", "notes on", "alpha", or "rabbit hole" → alpha-learn. If they say "process", "store", "add to knowledge" → this skill.
+Never summarize a video from model memory; that is fabrication.
 
 ## Bootstrap (ALWAYS Run First)
 
@@ -36,30 +34,57 @@ if ! command -v atris &> /dev/null; then
   npm install -g atris
 fi
 
-# 2. Check login
+# 2. Optional login (required only for process / credits)
 if [ ! -f ~/.atris/credentials.json ]; then
-  echo "Not logged in. Run: atris login"
-  exit 1
+  echo "Not logged in. Search and notes still work. Process needs: atris login"
 fi
 
-# 3. Extract token
-if command -v node &> /dev/null; then
-  TOKEN=$(node -e "console.log(require('$HOME/.atris/credentials.json').token)")
-elif command -v python3 &> /dev/null; then
-  TOKEN=$(python3 -c "import json,os; print(json.load(open(os.path.expanduser('~/.atris/credentials.json')))['token'])")
-elif command -v jq &> /dev/null; then
-  TOKEN=$(jq -r '.token' ~/.atris/credentials.json)
-else
-  echo "Error: Need node, python3, or jq to read credentials"
-  exit 1
+# 3. Extract token when present
+if [ -f ~/.atris/credentials.json ]; then
+  if command -v node &> /dev/null; then
+    TOKEN=$(node -e "console.log(require('$HOME/.atris/credentials.json').token)")
+  elif command -v python3 &> /dev/null; then
+    TOKEN=$(python3 -c "import json,os; print(json.load(open(os.path.expanduser('~/.atris/credentials.json')))['token'])")
+  elif command -v jq &> /dev/null; then
+    TOKEN=$(jq -r '.token' ~/.atris/credentials.json)
+  fi
+  export ATRIS_TOKEN="$TOKEN"
 fi
 
-echo "Ready. YouTube skill active (5 credits per video)."
-export ATRIS_TOKEN="$TOKEN"
+echo "Ready. YouTube skill active (search + notes free; process 5 credits)."
 ```
 
 ---
 
+## Search videos (free)
+
+```bash
+atris youtube search "MCP agents 2026"
+atris youtube search "MCP agents" --limit 10
+atris youtube search "MCP agents" --json
+```
+
+Uses `ytsearch` on PATH when present, else bundled `scripts/det/ytsearch`, else `yt-dlp --flat-playlist --print` with `ytsearchN:`. No credits. No `/agent/process_youtube` call.
+
+## Paid search (5 credits)
+
+```bash
+atris youtube search --paid "MCP agents 2026"
+atris youtube search --paid "MCP agents" --limit 10
+```
+
+Requires login. Uses the stored token, or mints a youtube-scope agent token from disk the same way as `atris youtube process` and `atris x-search`. Never `/auth/cli`. Prints `title | watch permalink` plus credits. Empty or failed searches refund.
+
+Line contract:
+
+```text
+title | channel | duration | views | upload_date | https://youtu.be/ID
+```
+
+`upload_date` is `YYYYMMDD` (or `NA`) so callers can apply a freshness gate (for example last 6 weeks). After the user picks a URL, run notes (free) or process (5 credits).
+
+---
+
 ## API Reference
 
 Base: `https://api.atris.ai/api`
@@ -118,18 +143,23 @@ atris youtube process "https://www.youtube.com/watch?v=..." \
 
 ## Workflows
 
+### "Find YouTube videos about X"
+1. Search: `atris youtube search "X" --limit 10`
+2. Show title, channel, duration, views, upload_date, and the youtu.be link
+3. Stop. Let the user pick. Do not auto-process.
+
 ### "Learn from this YouTube video"
 1. Run bootstrap
-2. Process: `atris youtube process <url> --query "Create an outline, claims, examples, takeaways, Atris implications, and next actions."`
+2. Notes first: `atris youtube notes <url>`
 3. Display the analysis as flowing prose: ideas and who said them, never timecodes. Timestamps stay in the stored notes file for verification, not in the reply.
 
 ### "What does this video say about X?"
 1. Run bootstrap
-2. Process with focused query: `atris youtube process <url> --query "What does this say about X?"`
+2. Notes or process with focused query: `atris youtube process <url> --query "What does this say about X?"`
 3. Show the focused analysis as prose; cite the speaker, not the clock
 
 ### "Process multiple videos on a topic"
-1. Run bootstrap
+1. Search to discover links (free), or use URLs the user already has
 2. Process each sequentially (each = 5 credits):
 ```bash
 VIDEOS=(
@@ -171,13 +201,20 @@ Two layers, never mixed. The reply the person reads is flowing prose: ideas, spe
 
 ## How It Works
 
-`atris youtube` first tries local transcript extraction with `yt-dlp`. It sends timestamped `transcript_text` to `/agent/process_youtube` with `cache_transcript=false`. If local transcript processing fails with a retryable error, it falls back to cloud video processing. Use `--json` to inspect `metadata.processing_method` and `metadata.transcript_source`.
+`atris youtube search` shells to local ytsearch/yt-dlp and never hits the Atris API.
+
+`atris youtube search --paid` posts `{query, limit}` to `/youtube/search` with bearer auth. Agent tokens need the youtube scope.
+
+`atris youtube` process first tries local transcript extraction with `yt-dlp`. It sends timestamped `transcript_text` to `/agent/process_youtube` with `cache_transcript=false`. If local transcript processing fails with a retryable error, it falls back to cloud video processing. Use `--json` to inspect `metadata.processing_method` and `metadata.transcript_source`.
 
 ---
 
 ## Billing
 
-- **5 credits per video** (flat rate, any length)
+- **Search: 0 credits** (local discovery)
+- **Paid search: 5 credits** (`--paid`; refund on empty or fail)
+- **Notes: 0 credits** (local captions + engine)
+- **Process: 5 credits per video** (flat rate, any length)
 - Credits deducted before processing
 - **Full refund** if Gemini fails or returns an error
 - Insufficient credits returns 402 with your current balance
@@ -192,6 +229,8 @@ Two layers, never mixed. The reply the person reads is flowing prose: ideas, spe
 | `402` | Not enough credits | Check balance, purchase at atris.ai |
 | `400` | Invalid YouTube URL | Check URL format |
 | `502` | Transcript or cloud processing failed | Retry; credits auto-refunded when backend fails |
+| search exit 2 | ytsearch/yt-dlp missing or no results | Install yt-dlp, or put ytsearch on PATH |
+| search 429 | YouTube rate-limited local search | serve last same-query free rows if younger than one hour; otherwise retry later; do not use --paid |
 
 ---
 
@@ -201,10 +240,20 @@ Two layers, never mixed. The reply the person reads is flowing prose: ideas, spe
 # Setup (once)
 npm install -g atris && atris login
 
-# Get token
+# Free: discover videos
+atris youtube search "MCP agents 2026"
+atris youtube search "MCP agents" --limit 10
+
+# Paid: watch permalinks from Atris (5 credits)
+atris youtube search --paid "MCP agents 2026"
+
+# Free: notes on a URL you already have
+atris youtube notes "https://youtu.be/VIDEO_ID"
+
+# Get token (process only)
 TOKEN=$(node -e "console.log(require('$HOME/.atris/credentials.json').token)")
 
-# Process a video
+# Process a video (5 credits)
 atris youtube process "https://youtube.com/watch?v=..." --query "Create a outline (flowing, idea-first) and action brief"
 
 # Process + store to agent knowledge

package/atris/team/_template/SOUL.md

@@ -0,0 +1,40 @@
+---
+name: template-soul
+version: 1.0.0
+born: YYYY-MM-DD
+---
+
+# Soul
+
+What this agent believes, values, and has learned — not what it does (that's MEMBER.md) or how it communicates (that's PERSONA.md). This is who it is when the rules run out.
+
+## Beliefs
+
+What you hold true about your work. Not rules — convictions.
+
+- (Replace with 3-5 beliefs that guide judgment in ambiguous situations)
+
+## Values
+
+What you optimize for when nothing else tells you what to do.
+
+- (Replace with 2-3 values, ordered by priority)
+
+## Lessons
+
+Hard-won patterns from experience. Updated as the agent works.
+
+- (Empty until the agent has lived. Synthesized from journal entries, not copied.)
+
+## Edges
+
+Where this agent's judgment is strong and where it's weak. Honest self-assessment.
+
+- **Strong:** (what this agent is unusually good at)
+- **Weak:** (what this agent tends to get wrong or overlook)
+
+## Voice
+
+Not communication style (that's PERSONA.md). This is the inner voice — the thing the agent says to itself before deciding.
+
+- (One sentence that captures how this agent thinks)

package/atris/team/validator/MEMBER.md

@@ -125,11 +125,10 @@ Review is not complete until residual risk is named.
 │ ✓ MAP.md updated (if needed)        │
 │ ✓ Wiki status checked (if present)  │
 │ ✓ Error handling present            │
-│ ✓ Anti-slop check (see below)       │
 └─────────────────────────────────────┘
 ```
 
-**Anti-slop gate:** Run `atris/policies/ANTISLOP.md` checklist on all output. Block if violations.
+**Anti-slop:** The build enforces deterministic tells; see `commands/slop.js`. Review only the remaining judgment calls in `atris/policies/ANTISLOP.md`.
 
 **Final ASCII:**
 ```

package/bin/atris

@@ -0,0 +1,21 @@
+#!/bin/sh
+# Tiny POSIX shim so sandboxes that refuse a large Node bin still get a
+# runnable public entry. Real CLI lives next to this file as atris.js.
+# Resolve symlinks so npm/global PATH links still find atris.js.
+set -eu
+here=$0
+while [ -h "$here" ]; do
+  link=$(ls -ld "$here")
+  link=${link#*" -> "}
+  case $link in
+    /*) here=$link ;;
+    *) here=$(dirname "$here")/$link ;;
+  esac
+done
+DIR=$(CDPATH= cd -- "$(dirname "$here")" && pwd)
+if command -v node >/dev/null 2>&1; then
+  exec node "$DIR/atris.js" "$@"
+fi
+echo "atris: node not found on PATH. install Node 22+ then retry." >&2
+echo "hint: atris doctor --json" >&2
+exit 127