atris 3.30.6 → 3.30.8

package/AGENTS.md

@@ -61,6 +61,14 @@ Always-on agents should move proof-backed work to Review, complete their native
 goal, then continue the mission loop with the next goal. They must not run
 `atris task accept` or claim AgentXP unless a human approved the proof.
 
+Mission-shaped user intent wins before normal task selection. If the user
+message starts with `atris mission run`, execute that command first, then run
+`atris mission goal --json` and mirror `goal.visible_goal` into the native chat
+goal. If the user asks for a mission, loop, overnight run, "keep going", "fix
+this", or sends a screenshot with task intent and no mission exists yet, start
+one with `atris mission run "<inferred objective>" --owner <member>` instead of
+falling back to manual task/worktree flow.
+
 Codex agents with native goal tools should run `atris mission goal --json`
 before choosing work. If the payload includes `goal.visible_goal`, mirror
 `goal.objective` into the visible chat goal when the current goal is empty,
@@ -77,7 +85,10 @@ CHECK → atris review (verify + cleanup)
 
 ## Parallel Member Worktrees
 
-When multiple members, Codex/Claude subagents, or other agents may touch a repo, start in an isolated checkout:
+Default to the current checkout for small, clean, single-agent fixes. Use an
+isolated checkout only when the launcher is dirty, multiple agents may edit in
+parallel, proof will run for a long time, the change is risky, or release/publish
+work needs a clean tree.
 
 ```bash
 atris worktree guide
@@ -87,7 +98,7 @@ cd <printed path>
 atris worktree ship --message "<commit summary>" --verify "<test command>" --merge
 ```
 
-This ties member/agent identity, mission/member state, branch name, isolated checkout, optional Swarlo claim, verification, push, PR, and merge together. Use `atris worktree status` before broad staging or cleanup.
+This ties member/agent identity, mission/member state, branch name, isolated checkout, optional Swarlo claim, verification, push, PR, and merge together. Use `atris worktree status` before broad staging and `atris worktree cleanup` / `atris worktree cleanup --apply` to remove clean merged worktrees.
 
 ## Mission Autonomy
 

package/README.md

@@ -91,7 +91,7 @@ Integrates with any agent.
 
 ```bash
 cd your-project
-ax chat ax --fast
+ax --fast --chat
 ax --fast "hello"
 ax --pro "help me plan this task"
 ax --max "reason through this hard decision"

package/atris/AGENTS.md

@@ -22,6 +22,9 @@ section.
 ## Mission Autonomy
 
 Use `atris mission` when work should survive this chat or run as an autonomous loop.
+Mission-shaped user intent wins before normal task selection: if the user says
+`atris mission run ...`, execute it first, then run `atris mission goal --json`
+and mirror `goal.visible_goal`.
 
 ```
 member -> mission start --verify -> status --status active -> one bounded step -> mission tick --verify -> receipt -> complete|run|stop
@@ -62,6 +65,10 @@ before choosing work. If the payload includes `goal.visible_goal`, mirror
 complete, or already matching; never complete unrelated active goals just to
 make room.
 
+Default to the current checkout for small, clean, single-agent fixes. Use
+worktrees only for dirty launchers, parallel agents, long proof, risky edits, or
+release/publish work; clean old merged worktrees with `atris worktree cleanup`.
+
 Do not write new operating doctrine here first. Add it to Atris policy, skills,
 wiki, or `atris/atris.md`, then regenerate this adapter if needed.
 

package/atris/CLAUDE.md

@@ -70,6 +70,9 @@ Do not write new operating doctrine here first. Add it to Atris policy, skills,
 ## Mission Autonomy
 
 Use `atris mission` when work should survive this chat or run as an autonomous loop.
+Mission-shaped user intent wins before normal task selection: if the user says
+`atris mission run ...`, execute it first, then run `atris mission goal --json`
+and mirror `goal.visible_goal`.
 
 ```
 member -> mission start --verify -> status --status active -> one bounded step -> mission tick --verify -> receipt -> complete|run|stop
@@ -81,6 +84,10 @@ member -> mission start --verify -> status --status active -> one bounded step -
 - Prove: after one bounded step, run `atris mission tick <id> --verify --summary "<what changed>"`.
 - Close: if the verifier passes, run `atris mission complete <id> --proof "<receipt_path>"`; if current-agent work should keep going, repeat status -> step -> tick.
 
+Default to the current checkout for small, clean, single-agent fixes. Use
+worktrees only for dirty launchers, parallel agents, long proof, risky edits, or
+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`).
 
 ## Rules (Non‑Negotiable)

package/atris/GEMINI.md

@@ -39,6 +39,9 @@ This is the Atris boot sequence. Show the output to the user, then respond natur
 ## Mission Autonomy
 
 Use `atris mission` when work should survive this chat or run as an autonomous loop.
+Mission-shaped user intent wins before normal task selection: if the user says
+`atris mission run ...`, execute it first, then run `atris mission goal --json`
+and mirror `goal.visible_goal`.
 
 ```
 member -> mission start --verify -> status --status active -> one bounded step -> mission tick --verify -> receipt -> complete|run|stop
@@ -50,6 +53,10 @@ member -> mission start --verify -> status --status active -> one bounded step -
 - Prove: after one bounded step, run `atris mission tick <id> --verify --summary "<what changed>"`.
 - Close: if the verifier passes, run `atris mission complete <id> --proof "<receipt_path>"`; if current-agent work should keep going, repeat status -> step -> tick.
 
+Default to the current checkout for small, clean, single-agent fixes. Use
+worktrees only for dirty launchers, parallel agents, long proof, risky edits, or
+release/publish work; clean old merged worktrees with `atris worktree cleanup`.
+
 ## Rules
 
 - Plan = ASCII visualization + approval gate. Do not execute during planning.

package/atris/skills/atris/SKILL.md

@@ -28,6 +28,7 @@ Detect: Project has `atris/` folder with MAP.md, TODO.md, PERSONA.md
 Commands: plan → do → review
 
 Key behaviors:
+- Mission-shaped intent wins: run `atris mission run ...` before normal task selection when the user invokes it or asks for a loop.
 - Read PERSONA.md (3-4 sentences, ASCII visuals)
 - Check MAP.md for file:line refs
 - Use `atris task` for claims, proof, ready, and accept
@@ -35,6 +36,24 @@ Key behaviors:
 - Treat TODO.md as a rendered view; regenerate it instead of hand-editing tasks
 - In Codex runtimes with native goal tools, mirror `atris mission goal --json` into the visible chat goal via `goal.visible_goal`
 
+## Mission Intent Intercept
+
+Before checking existing tasks, inspect the user's message. If it starts with
+`atris mission run`, execute that command first. Then run
+`atris mission goal --json` and mirror `goal.visible_goal` into the runtime's
+native goal when available.
+
+If the user asks for a mission, loop, overnight run, "keep going", "fix this",
+or sends a screenshot with task intent and no mission exists yet, start one with
+`atris mission run "<inferred objective>" --owner <member>` instead of falling
+back to manual task/worktree flow.
+
+Worktrees are not the default. Stay in the current checkout for small, clean,
+single-agent fixes. Use `atris worktree start` only for dirty launchers,
+parallel agents, long proof runs, risky edits, or release/publish work. Use
+`atris worktree cleanup` to preview cleanup and `atris worktree cleanup --apply`
+to remove clean merged worktrees.
+
 ## Visible Chat Goal Mirror
 
 Before choosing work in an Atris repo, run:
@@ -59,7 +78,8 @@ goal after proof is ready; only a human should run `atris task accept`.
 
 1. Run `atris atris.md` on first interaction to show workspace status
 2. Read `atris/MAP.md` before any file search to find file:line refs
-3. Run `atris mission goal --json` and mirror `goal.visible_goal` into the native chat goal when the runtime supports it
-4. Run `atris task list` or `atris task next` to find current work
-5. Claim tasks with `atris task claim <id> --as <functional-member>`
-6. Move completed work to review with `atris task ready <id> --proof "..."`
+3. If user intent is mission-shaped, run `atris mission run ...` before task flow
+4. Run `atris mission goal --json` and mirror `goal.visible_goal` into the native chat goal when the runtime supports it
+5. Run `atris task list` or `atris task next` only after mission intent is handled
+6. Claim tasks with `atris task claim <id> --as <functional-member>`
+7. Move completed work to review with `atris task ready <id> --proof "..."`

package/ax

@@ -17,6 +17,7 @@ const BACKEND = {
   path: '/api/atris2/turn'
 };
 const DEFAULT_BACKEND_BASE = `http://${BACKEND.host}:${BACKEND.port}`;
+const CLOUD_BACKEND_BASE = 'https://api.atris.ai';
 const CODE_FAST = {
   path: '/api/cursor/turn',
   model: 'composer-2-5-fast',
@@ -124,11 +125,11 @@ function formatUsage() {
     '  ax [--max|--fast] --benchmark',
     '',
     'Modes:',
-    '  --max   local workspace agent, highest reasoning, slowest turns',
-    '  --pro   local workspace agent, deeper tool loop',
-    '  --fast  local workspace agent, faster low-latency turns',
+    '  --max   highest reasoning, slowest turns',
+    '  --pro   deeper tool loop',
+    '  --fast  faster low-latency turns',
     '  --code-fast  Atris Code Fast public lane',
-    '  --local force local workspace tools',
+    '  --local force local workspace tools with your own AtrisOS backend',
     '  --cloud force authenticated cloud connectors/chat',
     '  --business <slug>  run tools on that business cloud workspace (EC2)',
     '  --verify <cmd>  gate the turn on this command passing (default: no verifier)',
@@ -209,19 +210,20 @@ function createRunLogger({ cwd = process.cwd(), mode = 'pro', kind = 'play', out
   };
 }
 
-function backendBaseUrl() {
-  return (process.env.AX_BACKEND_URL
+function backendBaseUrl(options = {}) {
+  const explicitBase = process.env.AX_BACKEND_URL
     || process.env.OBELISK_LOCAL_ATRIS2_BACKEND_URL
-    || process.env.OBELISK_ATRIS2_BACKEND_URL
-    || DEFAULT_BACKEND_BASE).replace(/\/$/, '');
+    || process.env.OBELISK_ATRIS2_BACKEND_URL;
+  if (explicitBase) return explicitBase.replace(/\/$/, '');
+  return options.route === 'cloud' ? CLOUD_BACKEND_BASE : DEFAULT_BACKEND_BASE;
 }
 
-function backendUrl() {
-  return new URL(BACKEND.path, backendBaseUrl()).toString();
+function backendUrl(options = {}) {
+  return new URL(BACKEND.path, backendBaseUrl(options)).toString();
 }
 
-function backendPathUrl(pathname) {
-  return new URL(pathname, backendBaseUrl()).toString();
+function backendPathUrl(pathname, options = {}) {
+  return new URL(pathname, backendBaseUrl(options)).toString();
 }
 
 function codeFastBaseUrl() {
@@ -266,10 +268,11 @@ function buildRunProfile(options = {}) {
       reasoning: 'Composer 2.5 fast lane; charges 10 credits per public turn'
     };
   }
-  const route = resolveRoute(options.message || 'doctor', options);
-  const payload = buildPayload(options.message || 'doctor', { mode, cwd, route });
+  const profileMessage = options.message || 'what files are here?';
+  const route = resolveRoute(profileMessage, options);
+  const payload = buildPayload(profileMessage, { mode, cwd, route });
   return {
-    endpoint: backendUrl(),
+    endpoint: backendUrl({ route }),
     mode,
     route,
     model: payload.model,
@@ -302,7 +305,7 @@ function formatRunProfile(profile, options = {}) {
 async function buildRuntimeHealth(options = {}) {
   const healthRes = options.healthRes
     ? await Promise.resolve(options.healthRes)
-    : await requestJson(ATRIS2_HEALTH_PATH, { token: '', timeoutMs: options.timeoutMs || 1500 });
+    : await requestJson(ATRIS2_HEALTH_PATH, { token: '', timeoutMs: options.timeoutMs || 1500, route: options.route || 'local' });
   const data = healthRes.ok && healthRes.data && typeof healthRes.data === 'object' ? healthRes.data : {};
   const models = Array.isArray(data.models) ? data.models : [];
   const fast = models.find(row => row && row.id === 'atris:fast') || null;
@@ -335,7 +338,7 @@ function formatRuntimeHealth(health, options = {}) {
     ['fast', fastReady ? 'ready' : 'not ready'],
     ['approvals', permissionReady ? 'ready' : 'offline'],
   ];
-  if (!backendReachable) rows.push(['fix', 'start local backend, then rerun ax --doctor']);
+  if (!backendReachable) rows.push(['fix', 'local backend offline; use hosted mode or start your AtrisOS backend']);
   return rows.map(([label, value]) => formatAuxRow(label, value, options)).join('\n');
 }
 
@@ -378,17 +381,17 @@ function authUserId() {
   }
 }
 
-function isLoopbackBackend() {
+function isLoopbackBackend(options = {}) {
   try {
-    const parsed = new URL(backendBaseUrl());
+    const parsed = new URL(backendBaseUrl(options));
     return ['127.0.0.1', 'localhost', '::1'].includes(parsed.hostname);
   } catch (_) {
     return false;
   }
 }
 
-function requestJson(pathname, { token = authToken(), timeoutMs = 6000 } = {}) {
-  const url = backendPathUrl(pathname);
+function requestJson(pathname, { token = authToken(), timeoutMs = 6000, route } = {}) {
+  const url = backendPathUrl(pathname, { route });
   const parsed = new URL(url);
   const transport = parsed.protocol === 'https:' ? https : http;
   return new Promise((resolve) => {
@@ -422,8 +425,8 @@ function requestJson(pathname, { token = authToken(), timeoutMs = 6000 } = {}) {
   });
 }
 
-function postJson(pathname, body, { token = authToken(), timeoutMs = 30000 } = {}) {
-  const url = backendPathUrl(pathname);
+function postJson(pathname, body, { token = authToken(), timeoutMs = 30000, route } = {}) {
+  const url = backendPathUrl(pathname, { route });
   const parsed = new URL(url);
   const transport = parsed.protocol === 'https:' ? https : http;
   const postData = JSON.stringify(body || {});
@@ -524,7 +527,7 @@ function cachedIntegrationStatus(options = {}) {
 
 async function buildConnectionContext(options = {}) {
   const token = options.token || authToken();
-  const localStatusUserId = isLoopbackBackend() ? authUserId() : '';
+  const localStatusUserId = isLoopbackBackend({ route: options.route }) ? authUserId() : '';
   const statusPath = localStatusUserId
     ? `${ATRIS2_CONNECTION_STATUS_PATH}?connection_user_id=${encodeURIComponent(localStatusUserId)}`
     : CONNECTION_STATUS_PATH;
@@ -532,9 +535,9 @@ async function buildConnectionContext(options = {}) {
     options.statusRes
       ? Promise.resolve(options.statusRes)
       : localStatusUserId || token
-        ? requestJson(statusPath, { token: localStatusUserId ? '' : token })
+        ? requestJson(statusPath, { token: localStatusUserId ? '' : token, route: options.route })
         : Promise.resolve({ ok: false, data: null }),
-    options.contractRes ? Promise.resolve(options.contractRes) : requestJson(CONNECTION_CAPABILITIES_PATH, { token: '' })
+    options.contractRes ? Promise.resolve(options.contractRes) : requestJson(CONNECTION_CAPABILITIES_PATH, { token: '', route: options.route })
   ]);
   const statusData = statusRes.ok && statusRes.data && typeof statusRes.data === 'object' ? statusRes.data : {};
   const backendStatuses = statusData.statuses && typeof statusData.statuses === 'object' ? statusData.statuses : statusData;
@@ -595,7 +598,15 @@ function connectorWriteIntent(message) {
 }
 
 function workspaceIntent(message) {
-  return /\b(files?|folders?|repo|workspace|project|directory|tree|read|open|inspect|search|grep|find|locate|where|edit|write|change|modify|patch|fix|test|tests?|build|src|source|code|diff|git|backend|frontend|atris task|atris xp|xp game|career xp|agentxp|todo|map)\b/i.test(message || '');
+  return Boolean(workspaceIntentReason(message));
+}
+
+function workspaceIntentReason(message) {
+  const text = String(message || '');
+  if (/\b(files?|folders?|repo|workspace|project|directory|tree|src|source|code|diff|git|backend|frontend|atris task|atris xp|xp game|career xp|agentxp|todo|map|tests?)\b/i.test(text)) return 'prompt mentions workspace, file, code, or repo terms';
+  if (/(^|\s|["'`])(?:\.{0,2}\/)?[\w.-]+\/[\w./-]+|[\w.-]+\.(?:js|jsx|ts|tsx|mjs|cjs|json|md|py|rb|go|rs|java|css|scss|html|yml|yaml|toml|env|txt)\b/i.test(text)) return 'prompt names a file path or filename';
+  if (/\b(read|open|inspect|search|grep|find|locate|where|edit|write|change|modify|patch|fix|test|build|refactor)\b.*\b(this|file|folder|repo|workspace|project|directory|module|component|package|readme|source|code|branch|suite|build|bug)\b/i.test(text)) return 'prompt asks to operate on workspace material';
+  return '';
 }
 
 function githubWorkspaceIntent(message) {
@@ -605,11 +616,22 @@ function githubWorkspaceIntent(message) {
 }
 
 function resolveRoute(message, options = {}) {
-  if (options.route === 'local' || options.forceLocal) return 'local';
-  if (options.route === 'cloud' || options.forceCloud) return 'cloud';
-  if (githubWorkspaceIntent(message)) return 'local';
-  if (mentionsConnector(message) && !workspaceIntent(message)) return 'cloud';
-  return 'local';
+  return routeDecision(message, options).route;
+}
+
+function routeDecision(message, options = {}) {
+  if (options.route === 'local' || options.forceLocal) return { route: 'local', reason: 'explicit --local' };
+  if (options.route === 'cloud' || options.forceCloud) return { route: 'cloud', reason: 'explicit --cloud' };
+  if (githubWorkspaceIntent(message)) return { route: 'local', reason: 'prompt asks for GitHub repo mutation' };
+  const reason = workspaceIntentReason(message);
+  if (mentionsConnector(message) && !reason) return { route: 'cloud', reason: 'connector request uses hosted Atris' };
+  if (reason) return { route: 'local', reason };
+  return { route: 'cloud', reason: 'default hosted chat' };
+}
+
+function shouldPreflightRuntime(route, options = {}, mode = 'fast') {
+  if (options.skipRuntimePreflight || options.turnFunction || options.business || normalizeMode(mode) === 'code-fast') return false;
+  return route !== 'cloud';
 }
 
 function normalizeMode(mode) {
@@ -1323,11 +1345,11 @@ function creditsFromApprovalExecution(response) {
   return Number.isFinite(credits) && credits > 0 ? credits : null;
 }
 
-async function postApprovalExecution(approvalRequest, { model = 'atris:fast', token = authToken() } = {}) {
+async function postApprovalExecution(approvalRequest, { model = 'atris:fast', token = authToken(), route = 'cloud' } = {}) {
   return postJson(APPROVAL_EXECUTE_PATH, {
     model,
     approval_request: approvalRequest,
-  }, { token });
+  }, { token, route });
 }
 
 async function executeApprovalRequest(approvalRequest, {
@@ -1716,9 +1738,9 @@ async function postTurn(message, options = {}) {
     || mentionsConnector(message)
     || /\b(can you use|can you access|connected|connections?|integrations?|tools?|capabilities)\b/i.test(message || '');
   const connectionContext = options.connectionContext || (shouldSendConnectionContext
-    ? await buildConnectionContext({ token, localWorkspace: local })
+    ? await buildConnectionContext({ token, localWorkspace: local, route })
     : null);
-  const connectionUserId = !local && isLoopbackBackend() ? authUserId() : '';
+  const connectionUserId = !local && isLoopbackBackend({ route }) ? authUserId() : '';
   const payload = buildPayload(message, { ...options, route, connectionContext, connectionUserId });
   const postData = JSON.stringify(payload);
   const output = options.output || process.stdout;
@@ -1726,7 +1748,7 @@ async function postTurn(message, options = {}) {
   // 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;
-  const turnUrl = new URL(backendUrl());
+  const turnUrl = new URL(backendUrl({ route }));
   const transport = turnUrl.protocol === 'https:' ? https : http;
   const state = {
     events: [],
@@ -1968,23 +1990,22 @@ async function chat(options = {}) {
   output.write(`${formatHeader({ mode, cwd, chat: true }, output)}\n\n`);
   if (logger) output.write(`${formatAuxRow('log', formatPathSubject(logger.path, output), output)}\n\n`);
 
-  const runtimePreflight = { ready: false };
-  const ensureRuntimeReady = async () => {
-    if (runtimePreflight.ready) return true;
-    if (options.skipRuntimePreflight || options.turnFunction || options.business || normalizeMode(mode) === 'code-fast') {
-      runtimePreflight.ready = true;
+  const runtimePreflight = { localReady: false };
+  const ensureRuntimeReady = async (routeForTurn = 'local', decision = {}) => {
+    if (!shouldPreflightRuntime(routeForTurn, options, mode)) {
       return true;
     }
+    if (runtimePreflight.localReady) return true;
     const startedAt = Date.now();
     const health = options.runtimeHealth
       ? await Promise.resolve(options.runtimeHealth({ mode }))
-      : await buildRuntimeHealth({ timeoutMs: options.preflightTimeoutMs || 1200 });
+      : await buildRuntimeHealth({ timeoutMs: options.preflightTimeoutMs || 1200, route: 'local' });
     if (runtimeReadyForChat(health, mode)) {
-      runtimePreflight.ready = true;
+      runtimePreflight.localReady = true;
       return true;
     }
     output.write(`${formatRuntimeHealth(health, output)}\n\n`);
-    output.write(`${formatBackendHint()}\n`);
+    output.write(`${formatBackendHint({ routeReason: decision.reason, explicitLocal: decision.reason === 'explicit --local' })}\n`);
     output.write(`${formatDoneLine(Date.now() - startedAt)}\n\n`);
     return false;
   };
@@ -2025,7 +2046,7 @@ async function chat(options = {}) {
       return false;
     }
     if (pendingApprovalRequest && normalizeMode(mode) !== 'code-fast' && messageApprovesPendingApproval(trimmed)) {
-      if (!(await ensureRuntimeReady())) return false;
+      if (!(await ensureRuntimeReady('cloud'))) return false;
       const startedAt = Date.now();
       const approvalState = {
         events: [],
@@ -2070,8 +2091,11 @@ async function chat(options = {}) {
     }
 
     const pendingTaskPreview = latestPendingTaskPreview(history);
-    const route = pendingTaskPreview ? 'cloud' : options.route;
-    if (!(await ensureRuntimeReady())) return false;
+    const decision = pendingTaskPreview
+      ? { route: 'cloud', reason: 'pending approval stays on hosted Atris' }
+      : routeDecision(trimmed, { route: options.route });
+    const route = decision.route;
+    if (!(await ensureRuntimeReady(route, decision))) return false;
     const turnFunction = options.turnFunction || turnFunctionForMode(mode);
     const result = await turnFunction(trimmed, { mode, cwd, history, output, route, business: options.business, verify: options.verify, conversationId });
     if (result.output && !result.output.endsWith('\n')) output.write('\n');
@@ -2129,17 +2153,21 @@ async function chat(options = {}) {
   if (logger) logger.close(0);
 }
 
-function printBackendHint() {
+function printBackendHint(options = {}) {
   console.log('');
-  console.log(formatBackendHint());
+  console.log(formatBackendHint(options));
 }
 
-function backendStartCommand() {
-  return `cd /Users/keshavrao/arena/atrisos-backend/backend && ATRIS2_ALLOW_LOCAL_WORKSPACE=1 ENVIRONMENT=development ENV=development ../venv/bin/uvicorn main:app --host ${BACKEND.host} --port ${BACKEND.port}`;
+function backendStartCommand(options = {}) {
+  if (options.explicitLocal) return 'Start your AtrisOS backend, or retry with --cloud for hosted chat.';
+  return 'Start your AtrisOS backend for local workspace, or retry with --cloud for hosted cloud scratch.';
 }
 
-function formatBackendHint() {
-  return `Start backend:\n${backendStartCommand()}`;
+function formatBackendHint(options = {}) {
+  const lines = ['This requires local workspace mode, but no AtrisOS backend is running.'];
+  if (options.routeReason && !options.explicitLocal) lines.push(`Routed local because ${options.routeReason}.`);
+  lines.push(backendStartCommand(options));
+  return lines.join('\n');
 }
 
 function bufferedOutput() {
@@ -2257,6 +2285,7 @@ async function runSelfTest(options = {}) {
     try {
       await chat({
         mode: 'fast',
+        route: 'local',
         cwd: os.tmpdir(),
         input: Readable.from(['hi\n', 'exit\n']),
         output: chatOutput,
@@ -2277,7 +2306,9 @@ async function runSelfTest(options = {}) {
     const text = chunks.join('');
     assertSelfTest(healthCalls === 1, 'offline preflight repeated unexpectedly');
     assertSelfTest(/backend\s+offline/.test(text), 'offline backend status missing');
-    assertSelfTest(/Start backend:/.test(text) && /uvicorn main:app/.test(text), 'start-backend command missing');
+    assertSelfTest(/This requires local workspace mode, but no AtrisOS backend is running\./.test(text), 'local backend hint missing');
+    assertSelfTest(/retry with --cloud for hosted chat/.test(text), 'cloud retry hint missing');
+    assertSelfTest(!/\/Users\/keshavrao/.test(text), 'local backend hint leaked a developer path');
     assertSelfTest(!/secret-token/.test(text), 'offline preflight leaked error detail');
   }, results, output);
 
@@ -3001,7 +3032,11 @@ async function main() {
     console.log(formatDoneLine(result.durationMs, creditsFromState(result)));
   } catch (error) {
     console.error(`x ${error.message}`);
-    printBackendHint();
+    const decision = prompt
+      ? routeDecision(prompt, { route: route === 'auto' ? undefined : route })
+      : { route: forceLocal ? 'local' : 'cloud', reason: forceLocal ? 'explicit --local' : 'default hosted chat' };
+    const shouldShowBackendHint = decision.route === 'local';
+    if (shouldShowBackendHint) printBackendHint({ routeReason: decision.reason, explicitLocal: forceLocal || decision.reason === 'explicit --local' });
     process.exit(1);
   }
 }
@@ -3071,6 +3106,7 @@ module.exports = {
   renderStreamingMarkdown,
   renderTerminalMarkdown,
   resolveRoute,
+  shouldPreflightRuntime,
   runBenchmark,
   runSelfTest,
   runtimeReadyForChat,

package/commands/init.js

@@ -671,6 +671,14 @@ Always-on agents should move proof-backed work to Review, complete their native
 goal, then continue the mission loop with the next goal. They must not run
 \`atris task accept\` or claim AgentXP unless a human approved the proof.
 
+Mission-shaped user intent wins before normal task selection. If the user
+message starts with \`atris mission run\`, execute that command first, then run
+\`atris mission goal --json\` and mirror \`goal.visible_goal\` into the native chat
+goal. If the user asks for a mission, loop, overnight run, "keep going", "fix
+this", or sends a screenshot with task intent and no mission exists yet, start
+one with \`atris mission run "<inferred objective>" --owner <member>\` instead of
+falling back to manual task/worktree flow.
+
 Task owners are functional or feature members, not engines. Use \`task-planner\`,
 \`architect\`, \`mission-lead\`, \`validator\`, \`launcher\`, or a feature owner for
 assignment; put coding agent models like Codex and Claude in the \`executed_by\`
@@ -684,6 +692,15 @@ BUILD → atris do     (execute tasks)
 CHECK → atris review (verify + cleanup)
 \`\`\`
 
+## Worktrees
+
+Default to the current checkout for small, clean, single-agent fixes. Use
+\`atris worktree start\` only when the launcher is dirty, multiple agents may
+edit in parallel, proof will run for a long time, the change is risky, or
+release/publish work needs a clean tree. Use \`atris worktree cleanup\` to preview
+merged worktree removal and \`atris worktree cleanup --apply\` to remove clean
+merged worktrees.
+
 ## Mission Autonomy
 
 Use \`atris mission\` when work should survive this chat or run as an autonomous loop.

package/commands/mission.js

@@ -1888,11 +1888,13 @@ function codexVisibleGoalBridge(mission, goalObjective) {
       keep_if_matching: 'if current goal objective equals goal.objective, continue the mission',
       create_when_empty_or_completed: 'create_goal({ objective: goal.objective })',
       complete_after_proof: 'update_goal({ status: "complete" })',
+      refresh_on_phase_change: 'atris mission goal --json before continuing changed work',
       refresh_next_candidate: 'atris mission goal --json',
     },
     guardrails: [
       'Do not complete a human-set active goal unless it matches this mission goal or the mission receipt proves handoff.',
       'If create_goal fails because another goal is active, keep this bridge waiting for the visible goal slot.',
+      'When the work changes phase or objective, refresh the mission goal before continuing.',
     ],
   };
 }
@@ -1906,7 +1908,8 @@ function codexGoalToolContract(mission) {
     set_next_goal: 'use goal.visible_goal: create_goal({ objective: goal.objective }) when no active goal blocks the slot',
     visible_goal_bridge: 'goal.visible_goal',
     platform_requirement: 'Codex runtime must expose replace_goal/set_goal, or allow update_goal({ status: "complete" }) followed by create_goal({ objective }).',
-    runtime_tool_sequence: 'get_goal -> update_goal({ status: "complete" }) after proof -> atris mission goal --json -> create_goal({ objective: goal.objective })',
+    phase_change_refresh: 'before changed follow-up work, run atris mission goal --json and mirror the returned visible goal',
+    runtime_tool_sequence: 'get_goal -> update_goal({ status: "complete" }) after proof or phase change -> atris mission goal --json -> create_goal({ objective: goal.objective })',
     blocked_without_platform_goal_write: true,
     mission_id: mission.id,
   };
@@ -2422,6 +2425,10 @@ function cappedClaudeReceiptText(text, limit = 4000) {
 
 async function runMission(args) {
   const asJson = wantsJson(args);
+  if (hasFlag(args, '--help') || hasFlag(args, '-h')) {
+    help();
+    return;
+  }
   const dueMode = hasFlag(args, '--due');
   const skipClaude = hasFlag(args, '--no-claude');
   const verifyEach = !hasFlag(args, '--no-verify');
@@ -3277,6 +3284,7 @@ atris mission - durable goal + loop + owner + proof state
   atris mission goal [--heartbeat] [--json]
   atris mission goal-loop [--max-wall 28800] [--max-iterations 32] [--no-claude] [--json]
   atris mission tick <id> [--verify] [--complete-on-pass] [--summary "..."] [--json]
+  atris mission "<objective>" [--owner <member>]   Shortcut for: atris mission run "<objective>"
   atris mission run ["objective"|<member> ["objective"]|id|--due] [--owner <member>] [--max-ticks 4] [--max-wall 3600] [--cadence "15m"]
                                 [--no-claude] [--no-verify] [--complete-on-pass] [--no-drain] [--json]
                        (bare/member-only run prompts; one-word fuzzy intent starts a new visible-goal mission; --due runs the saved queue)
@@ -3513,6 +3521,7 @@ function missionCommand(args) {
     case '-h':
       return help();
     default:
+      if (subcommand && !String(subcommand).startsWith('-')) return runMission(args);
       return help();
   }
 }

package/commands/worktree.js

@@ -59,7 +59,10 @@ function parseWorktrees(text) {
       if (current.worktree) {
         let branch = current.branch || 'detached';
         branch = branch.replace(/^refs\/heads\//, '');
-        out.push({ path: current.worktree, branch, head: current.HEAD || '' });
+        const item = { path: current.worktree, branch, head: current.HEAD || '' };
+        if (current.locked) item.locked = true;
+        if (current.prunable) item.prunable = true;
+        out.push(item);
       }
       current = {};
       continue;
@@ -451,10 +454,98 @@ function prune(args) {
   return result.status || 0;
 }
 
+const PROTECTED_BRANCHES = new Set(['main', 'master']);
+
+function cleanupWorktrees({ root = repoRoot(), base: baseOverride = '', apply = false } = {}) {
+  const worktrees = listWorktrees(root);
+  const primary = worktrees[0]?.path ? path.resolve(worktrees[0].path) : '';
+  const current = path.resolve(root);
+  const base = normalizeTargetRef(root, baseOverride || defaultShipTarget(root));
+  refreshRemoteRef(root, base);
+  const candidates = [];
+  const kept = [];
+  const removed = [];
+
+  for (const wt of worktrees) {
+    const wtPath = path.resolve(wt.path);
+    const item = { path: wt.path, branch: wt.branch, head: wt.head };
+    if (wtPath === primary) {
+      kept.push({ ...item, reason: 'primary_checkout' });
+      continue;
+    }
+    if (wtPath === current) {
+      kept.push({ ...item, reason: 'current_checkout' });
+      continue;
+    }
+    if (wt.locked) {
+      kept.push({ ...item, reason: 'locked' });
+      continue;
+    }
+    if (PROTECTED_BRANCHES.has(wt.branch)) {
+      kept.push({ ...item, reason: 'protected_branch' });
+      continue;
+    }
+    const counts = statusCounts(wt.path);
+    if (!counts) {
+      kept.push({ ...item, reason: 'missing_or_unreadable' });
+      continue;
+    }
+    if (counts.staged || counts.unstaged || counts.untracked) {
+      kept.push({ ...item, reason: 'dirty', staged: counts.staged, unstaged: counts.unstaged, untracked: counts.untracked });
+      continue;
+    }
+    if (!wt.head) {
+      kept.push({ ...item, reason: 'missing_head' });
+      continue;
+    }
+    const merged = runGit(['merge-base', '--is-ancestor', wt.head, base], { cwd: root, check: false }).status === 0;
+    if (!merged) {
+      kept.push({ ...item, reason: 'unmerged' });
+      continue;
+    }
+    const candidate = { ...item, reason: 'merged_into_base' };
+    candidates.push(candidate);
+    if (!apply) continue;
+    const removedResult = runGit(['worktree', 'remove', wt.path], { cwd: root, check: false });
+    if (removedResult.status === 0) {
+      removed.push(candidate);
+    } else {
+      kept.push({ ...item, reason: 'remove_failed', error: (removedResult.stderr || removedResult.stdout || '').trim() });
+    }
+  }
+
+  return { apply, base, candidates, removed, kept };
+}
+
+function cleanup(args) {
+  const asJson = hasFlag(args, '--json');
+  const result = cleanupWorktrees({
+    root: repoRoot(),
+    base: readFlag(args, '--base'),
+    apply: hasFlag(args, '--apply'),
+  });
+  if (asJson) {
+    console.log(JSON.stringify({ ok: true, ...result }, null, 2));
+    return 0;
+  }
+  const action = result.apply ? 'removed' : 'candidate';
+  console.log(`cleanup: ${result.apply ? 'applied' : 'dry-run'} base=${result.base}`);
+  console.log(`${action}s: ${result.apply ? result.removed.length : result.candidates.length}`);
+  for (const item of result.apply ? result.removed : result.candidates) {
+    console.log(`${action}: ${item.path} branch=${item.branch} reason=${item.reason}`);
+  }
+  console.log(`kept: ${result.kept.length}`);
+  if (!result.apply && result.candidates.length) console.log('next: atris worktree cleanup --apply');
+  return 0;
+}
+
 function guide() {
   console.log('Atris worktree agent recipe');
   console.log('');
-  console.log('1. Start isolated work:');
+  console.log('Default: stay in the current checkout for small, clean, single-agent fixes.');
+  console.log('Use a worktree for dirty launchers, parallel agents, risky edits, releases, or long proof runs.');
+  console.log('');
+  console.log('1. Start isolated work when needed:');
   console.log('   atris worktree start --member <member> --task "<task>" --claim');
   console.log('   atris worktree start --agent <agent> --task "<task>"');
   console.log('');
@@ -471,13 +562,17 @@ function guide() {
   console.log('4. Ship only from the isolated worktree:');
   console.log('   atris worktree ship --message "<commit>" --verify "<cmd>" --merge');
   console.log('');
+  console.log('5. Clean merged worktrees:');
+  console.log('   atris worktree cleanup');
+  console.log('   atris worktree cleanup --apply');
+  console.log('');
   console.log('Notes: start uses the current upstream/default remote base, not dirty local HEAD.');
   console.log('Use `atris worktree status` to see all worktrees and dirty counts.');
   return 0;
 }
 
 function help() {
-  console.log('Usage: atris worktree <guide|start|ship|status|guard|prune>');
+  console.log('Usage: atris worktree <guide|start|ship|status|guard|prune|cleanup>');
   console.log('');
   console.log('  atris worktree guide');
   console.log('  atris worktree start --member <member>|--agent <name> --task "<task>" [--claim]');
@@ -485,6 +580,7 @@ function help() {
   console.log('  atris worktree status');
   console.log('  atris worktree guard [--allow-primary] [--allow-dirty]');
   console.log('  atris worktree prune [--apply]');
+  console.log('  atris worktree cleanup [--apply] [--json] [--base origin/master]');
 }
 
 function worktreeCommand(args = []) {
@@ -503,6 +599,7 @@ function worktreeCommand(args = []) {
   }
   if (sub === 'guard') return guard(rest);
   if (sub === 'prune') return prune(rest);
+  if (sub === 'cleanup' || sub === 'clean') return cleanup(rest);
   help();
   return 2;
 }
@@ -510,6 +607,7 @@ function worktreeCommand(args = []) {
 module.exports = {
   branchName,
   createAgentWorktree,
+  cleanupWorktrees,
   defaultShipTarget,
   defaultStartBase,
   defaultWorktreePath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.30.6",
+  "version": "3.30.8",
   "main": "bin/atris.js",
   "bin": {
     "atris": "bin/atris.js",