atris 3.31.0 → 3.32.0

package/README.md

@@ -81,7 +81,7 @@ atris
 
 `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 project memory checked for stale pages and missing context, use `atris loop`. `atris activate` surfaces wiki state from `atris/wiki/STATUS.md` when it exists.
+If you're still shaping the idea, use `atris brainstorm`. If you want one bounded mission pursued to proof, use `atris run "<objective>"`. If you want Atris to keep picking the next mission or member until you say stop, use `atris autopilot`. If you want project memory checked for stale pages and missing context, use `atris loop`. `atris activate` surfaces wiki state from `atris/wiki/STATUS.md` when it exists.
 
 Core loop: `plan` -> `do` -> `review`
 
@@ -186,14 +186,14 @@ atris business record atris/reports/2026-04-12-operator-recap.md --outcome mixed
 | `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 run` | One bounded mission pursuit: start or resume, tick, complete (`--legacy` for the old plan/do/review chain) |
 | `atris run logs` | Browse glass run logs (phase reasoning persisted to disk) |
 | `atris run prune-logs` | Prune old run logs, keeping only the most recent N |
 | `atris run search` | Search phase reasoning across all run logs by keyword |
 | `atris run stats` | Show run log stats: phase counts, avg durations |
 | `atris run export` | Export all run logs as a JSON bundle |
 | `atris run diff` | Compare two run logs side by side |
-| `atris autopilot` | Guided loop with approvals |
+| `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 now` | Show the current operating truth |

package/atris/CLAUDE.md

@@ -90,6 +90,14 @@ release/publish work; clean old merged worktrees with `atris worktree cleanup`.
 
 If the task produces durable project knowledge, update `atris/wiki/` or run the local wiki flow (`atris ingest`, `atris query`, `atris lint`).
 
+## How to Report
+
+The human approves work by reading, so how you report IS the product.
+
+- **Results are capabilities.** State what someone can do now that they couldn't before, then what it means for them or the business. Tests are one word ("verified"). Shape: "We did X, so you can now Y." Detail stays under the hood; the reader asks if they want more.
+- **Three results, air between them, rest on ask.** A report fits one screen with no scrolling.
+- **Stake first, then the move.** "Agents burn tokens hand-rolling parsers: add one shared view." Flags, ids, and identifiers belong in the body, never the headline.
+
 ## Rules (Non‑Negotiable)
 
 - Plan = ASCII visualization + approval gate. Do not execute during planning.

package/atris.md

@@ -80,6 +80,14 @@ The same discipline for words. Output stays sharp no matter how bloated the cont
 - **Cut filler.** Drop "it's worth noting", "in order to", "leverage", "seamless", "robust", "delve", stacked hedges, and em dashes. `atris slop` flags the prose tells (em-dash, hype-copy) too.
 - **Bound verbosity by information, not context.** Say the load-bearing thing and stop. Length tracks what the reader needs to act, nothing more.
 - **Match the register.** The operator wants the next move; a spec wants the contract; a journal wants one line. Jargon is a lever only when shared: use the reader's precise terms, define a new one once.
+- **Specific AND workable.** Vocabulary carries both: precise enough that another agent can act on it, plain enough that the operator gets it on a phone. A sentence only one of those audiences can use is half-written.
+- **Every queue item earns its surface.** Anything an operator might see (task title, mission objective, roadmap item, tick summary) carries its own why in the same sentence: what it costs to skip, or what it buys. "Agents burn tokens hand-rolling state parsers: add one shared inspect view" surfaces; "novel goal-chain demo" does not. Digests refuse raw titles that can't explain themselves.
+- **Day-one PM test.** Every sentence that reaches an operator must make sense to a PM who joined the company this morning: no internal codenames, no problem-titles standing in for results. If they'd have to ask "what does that mean?", the sentence is unfinished. Detail stays one ask away, always.
+- **Results are capabilities, not test counts.** When work lands, the sentence states what someone can do now that they couldn't before, then what it means for them or the business. Tests are one word ("verified"); the meaning is the sentence. Copy these shapes:
+  - "One word now runs the work: `atris autopilot` picks the next mission and keeps going until you say stop. Autonomy stopped being a setup and became a feature."
+  - "Missions survive everything: one engine starts the work, another picks it up cold, a third lands it. Work is no longer tied to a chat window, a session, or a vendor."
+  - "The system reports in plain English: one daily message with what landed, what waits on you, and who should own what's next. One person can supervise many projects."
+- **Fit the screen.** An operator-facing report shows three results, air between them, and holds the rest on ask. No scrolling: reading it is one glance, and the reader asks for more if they want more.
 
 `expected`: this is how an Atris agent writes and builds. Shipping slop or rambling is a failure smell, same as drift or a stale task.
 

package/ax

@@ -306,6 +306,20 @@ function formatRunProfile(profile, options = {}) {
   return rows.map(([label, value]) => formatAuxRow(label, value, options)).join('\n');
 }
 
+// Auto-routed local turns must never die on a missing local backend — a
+// consumer machine without the launchd service gets a degraded cloud chat
+// turn, not ECONNREFUSED. Probed once per process (REPL lines reuse it).
+// Explicit --local skips the downgrade so devs see the real error. Interim
+// guard until the cloud relay executes workspace tools in-process and
+// consumers stop needing a local backend at all.
+let _localBackendUp = null;
+async function localBackendReachable() {
+  if (_localBackendUp !== null) return _localBackendUp;
+  const res = await requestJson(ATRIS2_HEALTH_PATH, { timeoutMs: 1200, route: 'local' });
+  _localBackendUp = Boolean(res.ok || Number(res.status || 0) > 0);
+  return _localBackendUp;
+}
+
 async function buildRuntimeHealth(options = {}) {
   const route = options.route === 'local' || options.forceLocal ? 'local' : 'cloud';
   const healthRes = options.healthRes
@@ -621,9 +635,49 @@ function githubWorkspaceIntent(message) {
   return /\b(push|commit|commits?|branch|branches|checkout|merge|rebase|tag|release|pr|pull request|pull-request|repo change|code change|small change)\b/i.test(text);
 }
 
+// Walk up from cwd looking for a workspace marker (.git or atris/ or atris.md).
+// The process.cwd() answer is cached — resolveRoute runs per chat line — but an
+// explicit startDir (callers pass their own cwd) is always checked fresh.
+let _workspaceCwd = null;
+function insideWorkspaceCwd(startDir) {
+  const explicit = typeof startDir === 'string' && startDir.length > 0;
+  if (!explicit && _workspaceCwd !== null) return _workspaceCwd;
+  let dir = explicit ? startDir : process.cwd();
+  let found = false;
+  for (let i = 0; i < 24; i += 1) {
+    if (fs.existsSync(path.join(dir, '.git')) || fs.existsSync(path.join(dir, 'atris.md')) || fs.existsSync(path.join(dir, 'atris'))) {
+      found = true;
+      break;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  if (!explicit) _workspaceCwd = found;
+  return found;
+}
+
 function resolveRoute(message, options = {}) {
   if (options.route === 'local' || options.forceLocal) return 'local';
   if (options.route === 'cloud' || options.forceCloud) return 'cloud';
+  // Workspace standard v2 (2026-07-02, supersedes intent routing): inside a
+  // workspace, tools are ALWAYS attached and the model decides whether to use
+  // them — the Claude Code / Codex shape. v1 guessed intent with regexes and
+  // lost three times in one day ("in scripts/fast-coach/tick.mjs, what does
+  // SLOW_MS control?", "what did Atris ship last night?", "find it lol" — all
+  // tool-less misses that told the user to paste files they were sitting on).
+  // Measured cost of always-tools: pure math 3s vs 2s; and "plan my morning"
+  // through the tool lane reads the real task board instead of guessing.
+  // Non-workspace cwds stay pure cloud (the privacy line); explicit flags
+  // always win. One carve-out: GitHub-connector phrasing prefers the cloud
+  // GitHub API lane unless it names local-checkout work.
+  const text = String(message || '');
+  // Local-checkout work includes every git mutation verb: cloud chat can only
+  // read the GitHub connector, so "do a quick github push" through the cloud
+  // lane dead-ends in a write-blocked upsell (live miss 2026-07-02). Inside a
+  // workspace the local tool loop just runs git.
+  if (/\bgithub\b/i.test(text) && !/\b(commits?|branch(?:es)?|checkout|merge|rebase|changes?|diff|push(?:es|ed|ing)?|pull(?:s|ed|ing)?|fetch|clone|stash|tags?)\b/i.test(text)) return 'cloud';
+  if (insideWorkspaceCwd(options.cwd)) return 'local';
   return 'cloud';
 }
 
@@ -1871,6 +1925,19 @@ function codeFastWorkspaceNotice(result) {
 function handleEvent(event, state, output) {
   if (!event || typeof event !== 'object') return;
   state.events.push(event);
+  // AX_TIMING=1: phase scoreboard to stderr: one line per SSE event with ms
+  // since turn start and since the previous event, so latency work can see
+  // WHERE a slow turn spends its time (model TTFT vs tool exec vs loop count).
+  if (process.env.AX_TIMING === '1') {
+    const now = Date.now();
+    if (!state._t0) state._t0 = now;
+    const kind = event.type || event.status || 'event';
+    const detail = event.type === 'assistant_blocks' && Array.isArray(event.blocks)
+      ? event.blocks.map((b) => (b && b.type === 'tool_use' ? `tool:${b.tool}` : b && b.type)).join(',')
+      : event.type === 'tool_results' ? `results:${(event.results || []).length}` : '';
+    process.stderr.write(`[ax-timing] +${String(now - state._t0).padStart(6)}ms (gap ${String(now - (state._tPrev || now)).padStart(5)}ms) ${kind}${detail ? ' ' + detail : ''}\n`);
+    state._tPrev = now;
+  }
 
   if (event.type === 'system_init') {
     state.runtime = event;
@@ -1968,7 +2035,11 @@ function handleEvent(event, state, output) {
 }
 
 async function postTurn(message, options = {}) {
-  const route = options.business ? 'local' : resolveRoute(message, options);
+  let route = options.business ? 'local' : resolveRoute(message, options);
+  if (route === 'local' && !options.business && options.route !== 'local' && !options.forceLocal
+    && !(await localBackendReachable())) {
+    route = 'cloud';
+  }
   const local = route !== 'cloud';
   const endpointRoute = options.business ? 'cloud' : route;
   const token = authToken();
@@ -1987,7 +2058,11 @@ async function postTurn(message, options = {}) {
   // Relayed business turns wait on EC2 terminal calls (up to 60s each) with no
   // SSE traffic in between, so the socket-idle timeout needs more headroom.
   const baseTimeoutMs = payload.model === 'atris:max' ? 300000 : payload.model === 'atris:pro' ? 180000 : 60000;
-  const timeoutMs = options.business ? Math.max(baseTimeoutMs, 180000) : baseTimeoutMs;
+  let timeoutMs = options.business ? Math.max(baseTimeoutMs, 180000) : baseTimeoutMs;
+  // Local workspace tool loops (max_turns 8/14) legitimately run past the fast
+  // lane's 60s chat wall — SwapBench 2026-07-02: three tool-loop tasks died at
+  // ~60s as "Atris cloud did not respond". Same headroom as business relays.
+  if (local) timeoutMs = Math.max(timeoutMs, 180000);
   const turnUrl = new URL(backendUrl({ route: endpointRoute }));
   const transport = turnUrl.protocol === 'https:' ? https : http;
   const state = {
@@ -2357,7 +2432,15 @@ async function chat(options = {}) {
     const pendingTaskPreview = latestPendingTaskPreview(history);
     const route = pendingTaskPreview ? 'cloud' : options.route;
     maybeWriteAtrisGoalBanner(output, cwd);
-    const turnRoute = options.business ? 'cloud' : resolveRoute(trimmed, { route });
+    let turnRoute = options.business ? 'cloud' : resolveRoute(trimmed, { route, cwd });
+    // Same downgrade as postTurn: an auto-routed local turn with no local
+    // backend listening becomes a cloud turn instead of a blocked preflight
+    // that dumps localhost start instructions at a consumer. Explicit --local
+    // keeps the real error.
+    if (turnRoute === 'local' && route !== 'local' && !options.forceLocal) {
+      const probeLocal = options.localBackendProbe || localBackendReachable;
+      if (!(await probeLocal())) turnRoute = 'cloud';
+    }
     if (!(await ensureRuntimeReady(turnRoute))) return false;
     const turnFunction = options.turnFunction || turnFunctionForMode(mode);
     const turnId = options.turnId || createTurnId();
@@ -3311,7 +3394,14 @@ async function main() {
     console.log(formatDoneLine(result.durationMs, creditsFromState(result)));
   } catch (error) {
     console.error(`x ${error.message}`);
-    printBackendHint({ route: route === 'auto' ? undefined : route });
+    // Only name a lane when the user picked one. An auto-routed turn that
+    // failed locally must not claim "Atris cloud did not respond" (seen live
+    // 2026-07-02 after a local workspace-root rejection).
+    if (route === 'auto') {
+      console.error('\nRetry, or run ax --doctor to check the runtime.');
+    } else {
+      printBackendHint({ route });
+    }
     process.exit(1);
   }
 }

package/bin/atris.js

@@ -128,7 +128,16 @@ function isOptionValue(args, index, optionNames) {
 
 function applyRunnerFlags(args) {
   const runnerProfile = readOptionArg(args, '--runner-profile');
-  if (runnerProfile) process.env.ATRIS_RUNNER_PROFILE = runnerProfile;
+  if (runnerProfile) {
+    // Fail fast at the CLI boundary: an unknown profile otherwise stays silent
+    // until a heartbeat spawn resolves it mid-loop (silent overnight outage).
+    const { RUNNER_PROFILES, RUNNER_PROFILE_NAMES } = require('../lib/runner-command');
+    if (!Object.prototype.hasOwnProperty.call(RUNNER_PROFILES, runnerProfile)) {
+      console.error(`Unknown --runner-profile "${runnerProfile}". Known profiles: ${RUNNER_PROFILE_NAMES.join(', ')}.`);
+      process.exit(1);
+    }
+    process.env.ATRIS_RUNNER_PROFILE = runnerProfile;
+  }
   const runnerBin = readOptionArg(args, '--runner-bin');
   if (runnerBin) {
     process.env.ATRIS_RUNNER_BIN = runnerBin;
@@ -449,7 +458,7 @@ function showHelp() {
   console.log('  plan       - Create build spec with visualization');
   console.log('  do         - Execute tasks');
   console.log('  review     - Validate work (tests, safety checks, docs)');
-  console.log('  run        - Auto-chain plan→do→review (autonomous loop, auto-pushes)');
+  console.log('  run        - One bounded mission pursuit: start or resume, tick, complete');
   console.log('  run logs   - Browse glass run logs (phase reasoning persisted to disk)');
   console.log('  run search - Search phase reasoning across all run logs');
   console.log('  pulse      - Durable overnight self-improvement heartbeat (OS cron, install/status/tick)');
@@ -483,11 +492,12 @@ function showHelp() {
   console.log('');
   console.log('Optional helpers:');
   console.log('  brainstorm - Explore ideas conversationally before planning');
-  console.log('  autopilot  - Guided loop that can clarify TODOs and run plan → do → review');
+  console.log('  autopilot  - Keep the workspace moving: mission/member loop until you stop it');
   console.log('  improve    - Run one paid RL tick (POST /api/improve, deducts credits)');
   console.log('  worktree   - Isolated Git worktrees plus guarded ship/merge for parallel agents');
   console.log('  land       - The landing: what is actually done vs still in the air; --reap backs up + clears overdue');
   console.log('  autoland   - Approve the policy once; certified work lands itself, you keep irreversible calls');
+  console.log('  sign       - Co-author trailer on every commit in an atris workspace (on/off/status)');
   console.log('  visualize  - Generate a Slack/deck-ready visual from a prompt');
   console.log('  youtube    - Process YouTube videos with timestamped transcript-first analysis');
   console.log('');
@@ -547,7 +557,7 @@ function showHelp() {
   console.log('  soul       - Show, snapshot, or fork workspace identity');
   console.log('  fleet      - Inspect local fleet status');
   console.log('  agent      - Select cloud agent, spawn worker requests, or run `agent doctor`');
-  console.log('  chat       - Chat with the selected Atris agent (or: atris chat scan)');
+  console.log('  chat       - Chat with Atris 2 Fast in this workspace (--agent for cloud agent; or: atris chat scan)');
   console.log('  fast       - Chat with Atris2 Fast');
   console.log('  login      - Sign in or add another account');
   console.log('  logout     - Sign out of current account');
@@ -885,7 +895,7 @@ function showAutopilotHelp() {
   console.log('  --runner-bin PATH       Runner binary for this run');
   console.log('  --runner-template CMD   Runner command template for this run');
   console.log('  --runner-model MODEL    Runner model for this run');
-  console.log('  --runner-profile NAME   Runner profile for this run (e.g. atris-fast)');
+  console.log(`  --runner-profile NAME   Runner profile for this run (one of: ${require('../lib/runner-command').RUNNER_PROFILE_NAMES.join(', ')})`);
   console.log('');
   console.log('Examples:');
   console.log('  atris autopilot                        # Suggest from existing work');
@@ -927,7 +937,7 @@ const knownCommands = ['init', 'log', 'now', 'radar', 'ctop', 'launchpad', 'stat
                        'clean', 'harvest', 'verify', 'search', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'plugin', 'experiments', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube',
                        'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'probe', 'worktree', 'land', 'autoland', 'aeo', 'slop', 'strings', 'security-review', 'secure', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'xp', 'play', 'gm', 'x', 'recap', 'signup', 'clarity', 'moves',
                        'gmail', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
-                       'fork', 'browse', 'publish', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'compile', 'spaceship', 'truth'];
+                       'fork', 'browse', 'publish', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'compile', 'spaceship', 'truth', 'sign'];
 
 // Check if command is an atris.md spec file - triggers welcome visualization
 function isSpecFile(cmd) {
@@ -1831,23 +1841,26 @@ if (command === 'init') {
   }
   if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
     console.log('');
-    console.log('Usage: atris run [options]');
+    console.log('Usage: atris run ["objective"] [options]');
     console.log('');
-    console.log('Auto-chain plan → do → review cycles autonomously.');
-    console.log('Reads inbox ideas, creates tasks, builds them, validates, repeats.');
+    console.log('One bounded mission pursuit: start a mission from the objective');
+    console.log('(or resume the most logical runnable mission), tick it through the');
+    console.log('mission runtime, complete on pass, then exit.');
+    console.log('For an ongoing loop, use: atris autopilot');
     console.log('');
     console.log('Options:');
-    console.log('  --cycles=N    Max cycles (default: 5)');
-    console.log('  --once        Single plan→do→review cycle');
-    console.log('  --verbose     Show configured runner output');
-    console.log('  --dry-run     Preview without executing');
-    console.log('  --timeout=N   Phase timeout in seconds (default: 600)');
-    console.log('  --runner-bin PATH       Runner binary for this run');
-    console.log('  --runner-template CMD   Runner command template for this run');
-    console.log('  --runner-model MODEL    Runner model for this run');
-    console.log('  --runner-profile NAME   Runner profile for this run (e.g. atris-fast)');
-    console.log('  --push        Auto-push after each cycle (default: true)');
-    console.log('  --no-push     Skip auto-push after each cycle');
+    console.log('  --owner NAME      Mission owner (default: mission-lead)');
+    console.log('  --minutes N | --hours N   Time budget for the pursuit');
+    console.log('  --max-ticks N     Override the tick budget');
+    console.log('  --max-wall N      Override the wall clock in seconds');
+    console.log('  --cadence C       Mission cadence (e.g. 15m)');
+    console.log('  --no-complete     Skip auto-complete after a passing run');
+    console.log('  --legacy          Old plan→do→review loop (claude -p cycles)');
+    console.log('');
+    console.log('Legacy options (with --legacy):');
+    console.log('  --cycles=N --once --verbose --dry-run --timeout=N --no-push');
+    console.log('  --runner-bin PATH / --runner-template CMD / --runner-model MODEL');
+    console.log(`  --runner-profile NAME   Runner profile for this run (one of: ${require('../lib/runner-command').RUNNER_PROFILE_NAMES.join(', ')})`);
     console.log('');
     console.log('Subcommands:');
     console.log('  atris run logs [--tail N] [--cat FILE] [--json]  Browse glass run logs');
@@ -1860,62 +1873,81 @@ if (command === 'init') {
     process.exit(0);
   }
 
-  const verbose = args.includes('--verbose') || args.includes('-v');
-  const dryRun = args.includes('--dry-run');
-  const once = args.includes('--once');
-  const push = !args.includes('--no-push');
   applyRunnerFlags(args);
-  const cyclesArg = args.find(a => a.startsWith('--cycles='));
-  const maxCycles = cyclesArg ? parseInt(cyclesArg.split('=')[1]) : 5;
-  const timeoutArg = args.find(a => a.startsWith('--timeout='));
-  const timeout = timeoutArg ? parseInt(timeoutArg.split('=')[1]) * 1000 : undefined;
 
-  require('../commands/run').runAtris({ maxCycles, verbose, dryRun, once, push, timeout })
-    .then(() => process.exit(0))
-    .catch((error) => {
-      console.error(`\u2717 Run failed: ${error.message || error}`);
-      process.exit(1);
-    });
+  if (args.includes('--legacy')) {
+    const legacyArgs = args.filter(a => a !== '--legacy');
+    const verbose = legacyArgs.includes('--verbose') || legacyArgs.includes('-v');
+    const dryRun = legacyArgs.includes('--dry-run');
+    const once = legacyArgs.includes('--once');
+    const push = !legacyArgs.includes('--no-push');
+    const cyclesArg = legacyArgs.find(a => a.startsWith('--cycles='));
+    const maxCycles = cyclesArg ? parseInt(cyclesArg.split('=')[1]) : 5;
+    const timeoutArg = legacyArgs.find(a => a.startsWith('--timeout='));
+    const timeout = timeoutArg ? parseInt(timeoutArg.split('=')[1]) * 1000 : undefined;
+
+    require('../commands/run').runAtris({ maxCycles, verbose, dryRun, once, push, timeout })
+      .then(() => process.exit(0))
+      .catch((error) => {
+        console.error(`\u2717 Run failed: ${error.message || error}`);
+        process.exit(1);
+      });
+  } else {
+    require('../commands/run-front').runMissionFront(args)
+      .then((code) => process.exit(code || 0))
+      .catch((error) => {
+        console.error(`\u2717 Run failed: ${error.message || error}`);
+        process.exit(1);
+      });
+  }
 } else if (command === 'launchpad') {
   const code = require('../commands/launchpad').launchpadCommand(process.argv.slice(3));
   process.exit(code);
 } else if (command === 'autopilot') {
   const args = process.argv.slice(3);
-  if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
-    showAutopilotHelp();
-    process.exit(0);
-  }
-
-  // Parse options
-  const verbose = args.includes('--verbose') || args.includes('-v');
-  const dryRun = args.includes('--dry-run');
-  const auto = args.includes('--auto');
   applyRunnerFlags(args);
-  const maxIterationsArg = args.find(a => a.startsWith('--iterations='));
-  const maxIterations = maxIterationsArg ? parseInt(maxIterationsArg.split('=')[1]) : undefined;
-  const durationArg = args.find(a => a.startsWith('--duration='));
-  const duration = durationArg ? durationArg.split('=')[1] : null;
-
-  // Get description (non-flag args)
-  const description = args.filter((a, i) => !a.startsWith('-') && !isOptionValue(args, i, RUNNER_FLAG_NAMES)).join(' ').trim() || null;
-
-  const options = {
-    ...(maxIterations !== undefined && { maxIterations }),
-    verbose,
-    dryRun,
-    auto,
-    duration
-  };
 
-  let promise;
-  promise = require('../commands/autopilot').autopilotAtris(description, options);
+  if (args.includes('--legacy')) {
+    const legacyArgs = args.filter(a => a !== '--legacy');
+    if (legacyArgs.includes('--help') || legacyArgs.includes('-h') || legacyArgs[0] === 'help') {
+      showAutopilotHelp();
+      process.exit(0);
+    }
 
-  promise
-    .then(() => process.exit(0))
-    .catch((error) => {
-      console.error(`✗ Autopilot failed: ${error.message || error}`);
-      process.exit(1);
-    });
+    // Parse options
+    const verbose = legacyArgs.includes('--verbose') || legacyArgs.includes('-v');
+    const dryRun = legacyArgs.includes('--dry-run');
+    const auto = legacyArgs.includes('--auto');
+    const maxIterationsArg = legacyArgs.find(a => a.startsWith('--iterations='));
+    const maxIterations = maxIterationsArg ? parseInt(maxIterationsArg.split('=')[1]) : undefined;
+    const durationArg = legacyArgs.find(a => a.startsWith('--duration='));
+    const duration = durationArg ? durationArg.split('=')[1] : null;
+
+    // Get description (non-flag args)
+    const description = legacyArgs.filter((a, i) => !a.startsWith('-') && !isOptionValue(legacyArgs, i, RUNNER_FLAG_NAMES)).join(' ').trim() || null;
+
+    const options = {
+      ...(maxIterations !== undefined && { maxIterations }),
+      verbose,
+      dryRun,
+      auto,
+      duration
+    };
+
+    require('../commands/autopilot').autopilotAtris(description, options)
+      .then(() => process.exit(0))
+      .catch((error) => {
+        console.error(`✗ Autopilot failed: ${error.message || error}`);
+        process.exit(1);
+      });
+  } else {
+    Promise.resolve(require('../commands/autopilot-front').autopilotFront(args))
+      .then((code) => process.exit(code || 0))
+      .catch((error) => {
+        console.error(`✗ Autopilot failed: ${error.message || error}`);
+        process.exit(1);
+      });
+  }
 } else if (command === 'brainstorm') {
   require('../commands/brainstorm').brainstormAtris()
     .then(() => process.exit(0))
@@ -2240,6 +2272,10 @@ if (command === 'init') {
   Promise.resolve(require('../commands/compile').compileCommand(subcommand, ...args))
     .then(() => process.exit(process.exitCode || 0))
     .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
+} else if (command === 'sign') {
+  // Sign: prepare-commit-msg hook that credits Atris as co-author on commits in atris workspaces.
+  try { process.exit(require('../commands/sign').signCommand(process.argv[3]) || 0); }
+  catch (err) { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); }
 } else if (command === 'slop') {
   // Slop: deterministic frontend-slop detector (no LLM). Exit 1 = slop found, for CI + the autopilot gate.
   Promise.resolve(require('../commands/slop').slopCommand(process.argv.slice(3)))
@@ -2638,18 +2674,21 @@ async function agentAtris() {
 
 
 async function chatAtris() {
-  // Get message from command line args
-  const message = process.argv.slice(3).join(' ').trim();
+  // Get message from command line args; --agent forces the legacy cloud-agent lane
+  const rawArgs = process.argv.slice(3);
+  const agentLane = rawArgs.includes('--agent');
+  const message = rawArgs.filter(arg => arg !== '--agent').join(' ').trim();
 
   // Respect -h / --help before any auth/state checks
   if (message === '-h' || message === '--help' || message === 'help') {
     console.log('Usage: atris chat ["message"]');
     console.log('');
-    console.log('  Open an interactive session with the selected agent, or send a one-shot message.');
-    console.log('  Requires `atris login` and `atris agent` to be run first.');
+    console.log('  Chat with Atris 2 Fast in this workspace: tools attached, same turn as `ax --fast`.');
+    console.log('  Requires `atris login`.');
     console.log('');
-    console.log('  atris chat                  Interactive REPL with selected agent');
-    console.log('  atris chat "what now?"      One-shot message');
+    console.log('  atris chat                  Interactive chat (ax --fast --chat)');
+    console.log('  atris chat "what now?"      One-shot message (ax --fast)');
+    console.log('  atris chat --agent [...]    Legacy cloud-agent lane (needs `atris agent`)');
     process.exit(0);
   }
 
@@ -2665,6 +2704,22 @@ async function chatAtris() {
     process.exit(await runLocalFastMission(missionIntent));
   }
 
+  // Workspace standard v2: `atris chat` is the same turn as `ax --fast`,
+  // Atris 2 Fast with tools attached, ax owning routing (local tool loop,
+  // cloud fallback when no backend listens). The pro-chat cloud-agent lane
+  // survives behind --agent only; it 404s the moment a saved agent is
+  // deleted server-side and cannot see the workspace.
+  if (!agentLane) {
+    try {
+      const axPath = path.join(__dirname, '..', 'ax');
+      const axArgs = message ? ['--fast', message] : ['--fast', '--chat'];
+      const run = spawnSync(process.execPath, [axPath, ...axArgs], { stdio: 'inherit' });
+      process.exit(run.status || 0);
+    } catch {
+      // ax unavailable: fall through to the agent lane.
+    }
+  }
+
   printAtrisGoalBanner(process.cwd());
 
   // Check agent selected
@@ -2714,7 +2769,13 @@ async function chatOnce(config, credentials, message) {
     await streamProChat(endpoint, credentials.token, body);
     console.log('\n\n✓ Complete\n');
   } catch (error) {
-    console.error(`\n✗ Error: ${error.message || error}`);
+    const detail = String(error.message || error);
+    if (/404/.test(detail) && /agent not found/i.test(detail)) {
+      console.error(`\n✗ Error: Agent "${config.agent_name || agentId}" no longer exists on the server.`);
+      console.error('  Run "atris agent" to pick a new one, or drop --agent to use the fast workspace lane.');
+    } else {
+      console.error(`\n✗ Error: ${detail}`);
+    }
     process.exit(1);
   }
 }
@@ -2914,6 +2975,20 @@ async function atrisFastChat() {
     process.exit(await runLocalFastMission(missionIntent));
   }
 
+  // One routing brain: `atris fast` defers to ax's AX Context Standard. A
+  // workspace-shaped question asked from inside a workspace needs local tools
+  // (this lane is a tool-less cloud one-shot and confabulates on repo
+  // questions — SwapBench 2026-07-02), so delegate the whole turn to ax.
+  try {
+    const axModule = require('../ax');
+    if (axModule.resolveRoute(message) === 'local') {
+      const run = spawnSync(process.execPath, [path.join(__dirname, '..', 'ax'), '--fast', message], { stdio: 'inherit' });
+      process.exit(run.status || 0);
+    }
+  } catch {
+    // ax unavailable: fall through to the plain cloud one-shot.
+  }
+
   printAtrisGoalBanner(process.cwd());
 
   const ensured = await ensureValidCredentials();