atris 3.30.5 → 3.30.7

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;
@@ -609,7 +612,13 @@ function resolveRoute(message, options = {}) {
   if (options.route === 'cloud' || options.forceCloud) return 'cloud';
   if (githubWorkspaceIntent(message)) return 'local';
   if (mentionsConnector(message) && !workspaceIntent(message)) return 'cloud';
-  return 'local';
+  if (workspaceIntent(message)) return 'local';
+  return 'cloud';
+}
+
+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 +1332,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 +1725,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 +1735,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,19 +1977,18 @@ 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') => {
+    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`);
@@ -2025,7 +2033,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 +2078,8 @@ async function chat(options = {}) {
     }
 
     const pendingTaskPreview = latestPendingTaskPreview(history);
-    const route = pendingTaskPreview ? 'cloud' : options.route;
-    if (!(await ensureRuntimeReady())) return false;
+    const route = pendingTaskPreview ? 'cloud' : resolveRoute(trimmed, { route: options.route });
+    if (!(await ensureRuntimeReady(route))) 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');
@@ -2135,11 +2143,11 @@ function printBackendHint() {
 }
 
 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}`;
+  return 'Run without --local for hosted chat, or set AX_BACKEND_URL to your AtrisOS backend.';
 }
 
 function formatBackendHint() {
-  return `Start backend:\n${backendStartCommand()}`;
+  return `Local workspace mode needs a running AtrisOS backend:\n${backendStartCommand()}`;
 }
 
 function bufferedOutput() {
@@ -2257,6 +2265,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 +2286,8 @@ 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(/Local workspace mode needs a running AtrisOS backend:/.test(text), 'local backend 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 +3011,8 @@ async function main() {
     console.log(formatDoneLine(result.durationMs, creditsFromState(result)));
   } catch (error) {
     console.error(`x ${error.message}`);
-    printBackendHint();
+    const shouldShowBackendHint = forceLocal || (prompt && route !== 'cloud' && resolveRoute(prompt, { route: route === 'auto' ? undefined : route }) === 'local');
+    if (shouldShowBackendHint) printBackendHint();
     process.exit(1);
   }
 }
@@ -3071,6 +3082,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

@@ -10,6 +10,8 @@ const {
   resolveClaudeRunnerBin,
 } = require('../lib/runner-command');
 const {
+  FUNCTIONAL_MEMBER_TOPICS,
+  listWorkspaceMemberSlugs,
   normalizeOwnerSlug,
   resolveFunctionalOwner,
 } = require('../lib/functional-owner');
@@ -142,19 +144,48 @@ function printJsonOrText(payload, lines, asJson) {
   for (const line of lines) console.log(line);
 }
 
-function missionRunInputRequired(asJson = false) {
+const MISSION_RUN_VALUE_FLAGS = [
+  '--max-ticks',
+  '--max-wall',
+  '--cadence',
+  '--owner',
+  '--runner',
+  '--lane',
+  '--verify',
+  '--stop',
+  '--model',
+];
+const MISSION_RUN_BOOLEAN_FLAGS = [
+  '--json',
+  '--due',
+  '--no-claude',
+  '--no-verify',
+  '--complete-on-pass',
+  '--no-drain',
+  '--always-on',
+  '--xp-task',
+  '--agent-xp',
+];
+const DEFAULT_MISSION_RUN_OWNER_SLUGS = new Set(
+  FUNCTIONAL_MEMBER_TOPICS.map(topic => normalizeOwnerSlug(topic.owner)),
+);
+
+function missionRunInputRequired(asJson = false, owner = '') {
+  const defaultOwner = normalizeOwnerSlug(owner || process.env.ATRIS_AGENT_ID || 'mission-lead') || 'mission-lead';
   const payload = {
     ok: false,
     action: 'mission_input_required',
     prompt: 'What mission should Atris run?',
+    owner: defaultOwner,
     owner_prompt: 'Which team member should own it?',
-    example: 'atris mission run "make onboarding magical" --owner mission-lead',
+    example: `atris mission run "make onboarding magical" --owner ${defaultOwner}`,
   };
   if (asJson) {
     console.log(JSON.stringify(payload, null, 2));
   } else {
     console.error('What mission should Atris run?');
-    console.error('Try: atris mission run "make onboarding magical" --owner mission-lead');
+    if (defaultOwner) console.error(`Team member: ${defaultOwner}`);
+    console.error(`Try: atris mission run "make onboarding magical" --owner ${defaultOwner}`);
   }
   process.exit(1);
 }
@@ -178,6 +209,38 @@ function removeValueFlag(args, name) {
   return out;
 }
 
+function missionRunOwnerRef(ref, root = process.cwd()) {
+  const owner = normalizeOwnerSlug(ref);
+  if (!owner || /\s/.test(String(ref || ''))) return null;
+  if (listWorkspaceMemberSlugs(root).has(owner)) return owner;
+  if (DEFAULT_MISSION_RUN_OWNER_SLUGS.has(owner)) return owner;
+  return null;
+}
+
+function missionRunArgsWithOwner(args, owner) {
+  return [...removeValueFlag(args, '--owner'), '--owner', owner];
+}
+
+function missionRunInputFromArgs(args, root = process.cwd()) {
+  const positionals = stripKnownFlags(args, MISSION_RUN_VALUE_FLAGS, MISSION_RUN_BOOLEAN_FLAGS);
+  const explicitOwner = Boolean(readFlag(args, '--owner', ''));
+  if (!explicitOwner && positionals.length > 0) {
+    const owner = missionRunOwnerRef(positionals[0], root);
+    if (owner) {
+      return {
+        ref: positionals.slice(1).join(' ').trim(),
+        args: missionRunArgsWithOwner(args, owner),
+        owner,
+      };
+    }
+  }
+  return {
+    ref: positionals.join(' ').trim(),
+    args,
+    owner: readFlag(args, '--owner', ''),
+  };
+}
+
 async function promptMissionRunInput(args) {
   const defaultOwner = readFlag(args, '--owner', process.env.ATRIS_AGENT_ID || 'mission-lead');
   const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
@@ -1825,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.',
     ],
   };
 }
@@ -1843,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,
   };
@@ -2359,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');
@@ -2368,17 +2438,15 @@ async function runMission(args) {
   const maxTicks = Math.max(1, Number(maxTicksFlag) || MISSION_RUN_DEFAULTS.maxTicks);
   const maxWallSeconds = Math.max(60, Number(readFlag(args, '--max-wall', '')) || MISSION_RUN_DEFAULTS.maxWallSeconds);
   const cadenceOverride = readFlag(args, '--cadence', '');
-  const ref = stripKnownFlags(
-    args,
-    ['--max-ticks', '--max-wall', '--cadence', '--owner', '--runner', '--lane', '--verify', '--stop', '--model'],
-    ['--json', '--due', '--no-claude', '--no-verify', '--complete-on-pass', '--no-drain', '--always-on', '--xp-task', '--agent-xp'],
-  ).join(' ').trim();
+  const input = missionRunInputFromArgs(args);
+  const ref = input.ref;
+  const runArgs = input.args;
 
   if (!dueMode && !ref) {
     if (asJson || !process.stdin.isTTY || !process.stderr.isTTY) {
-      missionRunInputRequired(asJson);
+      missionRunInputRequired(asJson, input.owner);
     }
-    const prompted = await promptMissionRunInput(args);
+    const prompted = await promptMissionRunInput(runArgs);
     startMissionFromRunObjective(prompted.objective, prompted.args);
     return;
   }
@@ -2392,8 +2460,8 @@ async function runMission(args) {
     );
     return;
   }
-  if (!mission && ref && /\s/.test(ref) && !String(ref).startsWith('mission-')) {
-    startMissionFromRunObjective(ref, args);
+  if (!mission && ref && !String(ref).startsWith('mission-')) {
+    startMissionFromRunObjective(ref, runArgs);
     return;
   }
   if (!mission) {
@@ -3216,9 +3284,10 @@ 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 run ["objective"|id|--due] [--owner <member>] [--max-ticks 4] [--max-wall 3600] [--cadence "15m"]
+  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 run prompts for mission + owner; --due runs the saved queue)
+                       (bare/member-only run prompts; one-word fuzzy intent starts a new visible-goal mission; --due runs the saved queue)
                        (mission-run completions seed the next visible goal: decide and start the next useful mission)
   atris mission complete <id> --proof "..."
   atris mission stop <id> [--pause] [--reason "..."]
@@ -3452,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.5",
+  "version": "3.30.7",
   "main": "bin/atris.js",
   "bin": {
     "atris": "bin/atris.js",