atris 3.30.12 → 3.32.0

package/atris.md

@@ -49,6 +49,7 @@ Before changing anything, state:
 Then:
 - do not execute if another agent owns the same task or files
 - do not call something complete without verification
+- land or reap: work is not done until it is merged to the base branch or reaped; if you make a branch or worktree, you merge it or delete it before you stop. Run `atris land` to see limbo; anything past 7 days gets salvaged to `.atris/salvage/` and deleted by `atris land --reap`.
 - do not take irreversible actions without approval from the human
 - do not hide state outside markdown, logs, diffs, or the journal
 - do not edit the rules that judge you: the reward config, the authority policy, or this file
@@ -79,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.
 
@@ -106,6 +115,12 @@ atris task review <id> --lesson "<what improved>" --next "<next task>"
 
 Headless agents should add `--json` where available and read
 `.atris/state/tasks.projection.json` for a compact board view.
+
+Landing policy: when the owner has flipped `atris autoland on`, certified work
+(two independent review passes, real proof, safe verify re-run) lands itself
+with a receipt; agents never run `atris task accept` themselves. Money,
+deploys, security, customer, and outward-facing lanes always wait for the
+human. `atris autoland` shows what lands alone and what waits.
 Swarlo is the live coordination layer for claims, heartbeats, and reports; the
 task row/event stream remains the durable source of truth.
 

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';
 }
 
@@ -1165,6 +1219,51 @@ function formatApprovalTime(value) {
   return `${months[Number(month) - 1] || month} ${Number(day)}, ${year} at ${hour12}:${minute} ${ampm}`;
 }
 
+function previewText(value, limit = 80) {
+  return String(value || '').replace(/\s+/g, ' ').trim().slice(0, limit);
+}
+
+function previewContact(value) {
+  if (!value) return '';
+  if (typeof value === 'string') return previewText(value, 120);
+  if (typeof value !== 'object') return previewText(value, 120);
+  return previewText(value.email || value.address || value.value || value.name || '', 120);
+}
+
+function previewContacts(value) {
+  const values = Array.isArray(value)
+    ? value
+    : String(value || '').includes(',')
+      ? String(value).split(',')
+      : [value];
+  return values
+    .map(previewContact)
+    .filter(Boolean)
+    .slice(0, 3)
+    .join(', ');
+}
+
+function gmailApprovalDetails(receipt, request, approvalEvent = null) {
+  const payload = request && request.payload && typeof request.payload === 'object' ? request.payload : {};
+  const taskPreview = receipt && receipt.task_preview && typeof receipt.task_preview === 'object' ? receipt.task_preview : {};
+  const slots = taskPreview.slots && typeof taskPreview.slots === 'object' ? taskPreview.slots : {};
+  const preview = approvalEvent && approvalEvent.preview && typeof approvalEvent.preview === 'object' ? approvalEvent.preview : {};
+  return {
+    to: previewContacts(payload.to || payload.recipient || payload.recipients || payload.email || slots.to || slots.recipient || preview.to),
+    subject: previewText(payload.subject || payload.title || slots.subject || preview.subject, 80),
+  };
+}
+
+function isGmailApproval(request, approvalEvent = null, accept = {}) {
+  const connector = canonicalConnectorId((request && request.connector) || (approvalEvent && approvalEvent.tool));
+  const action = String(
+    (request && (request.executor_action_type || request.action_type || request.action))
+    || accept.task
+    || ''
+  ).toLowerCase().replace(/_/g, ' ');
+  return connector === 'gmail' && /\b(send|reply|compose)\b/.test(action);
+}
+
 function formatApprovalReceipt(receipt) {
   if (!receipt || typeof receipt !== 'object') return null;
   const events = Array.isArray(receipt.tool_events) ? receipt.tool_events : [];
@@ -1182,6 +1281,15 @@ function formatApprovalReceipt(receipt) {
     return `Approval needed before creation: calendar event "${String(title).slice(0, 80)}"${when ? ` ${when}` : ''}`;
   }
 
+  if (isGmailApproval(request, approvalEvent, accept)) {
+    const details = gmailApprovalDetails(receipt, request, approvalEvent);
+    const parts = [
+      details.to ? `to ${details.to}` : '',
+      details.subject ? `subject "${details.subject}"` : '',
+    ].filter(Boolean);
+    return `Approval needed before sending Gmail${parts.length ? `: ${parts.join(' ')}` : ''} (body hidden until approved)`;
+  }
+
   const connector = String(request.connector || approvalEvent.tool || 'connector').replace(/_/g, ' ');
   const action = String(request.action || actionType || 'action').replace(/_/g, ' ');
   return `Approval needed before ${action}: ${connector}`;
@@ -1210,6 +1318,16 @@ function formatTaskPreviewPlan(receipt) {
   if (!taskPreview) return null;
   const task = String(taskPreview.task || '').trim();
   const slots = taskPreview.slots && typeof taskPreview.slots === 'object' ? taskPreview.slots : {};
+  const approvalEvent = taskPreviewApprovalEvent(receipt);
+  const request = approvalEvent && approvalEvent.approval_request;
+  if (isGmailApproval(request, approvalEvent, receipt.task_accept_receipt || {}) || task === 'gmail.send_message') {
+    const details = gmailApprovalDetails(receipt, request || { payload: slots }, approvalEvent);
+    return [
+      'send Gmail',
+      details.to ? `to ${details.to}` : '',
+      details.subject ? `subject "${details.subject}"` : '',
+    ].filter(Boolean).join(' ');
+  }
   if (task === 'calendar.create_event') {
     const title = taskPreviewTitle(receipt);
     const start = slots.start || (receipt.task_accept_receipt && receipt.task_accept_receipt.start);
@@ -1712,12 +1830,30 @@ function buildMessage(message, history = []) {
   return String(message || '').trim();
 }
 
+function createTurnId() {
+  return `axt_${Date.now().toString(36)}_${crypto.randomBytes(4).toString('hex')}`;
+}
+
+function connectorTurnPolicy(message, options = {}) {
+  if (!connectorWriteIntent(message)) return null;
+  const policy = {
+    schema: 'ax.connector_turn.v1',
+    scope: 'current_turn_only',
+    policy: 'preview_then_explicit_approval',
+    writes_require_approval: true,
+  };
+  if (options.turnId) policy.turn_id = String(options.turnId);
+  if (options.conversationId) policy.conversation_id = String(options.conversationId);
+  return policy;
+}
+
 function buildPayload(message, options = {}) {
   const mode = normalizeMode(options.mode);
   const route = options.business ? 'local' : resolveRoute(message, options);
   const local = route !== 'cloud';
   const verifyCommand = String(options.verify || '').trim();
   const previousMessages = structuredHistory(options.history || []);
+  const turnId = String(options.turnId || '').trim();
   const payload = {
     message: buildMessage(message, options.history || []),
     model: modelForMode(mode),
@@ -1730,6 +1866,14 @@ function buildPayload(message, options = {}) {
   if (options.conversationId) {
     payload.conversation_id = String(options.conversationId);
   }
+  if (turnId) {
+    payload.turn_id = turnId;
+  }
+  const connectorPolicy = !local ? connectorTurnPolicy(message, { ...options, turnId }) : null;
+  if (connectorPolicy) {
+    payload.connector_turn = connectorPolicy;
+    payload.external_action_policy = 'preview_then_explicit_approval';
+  }
   if (options.business) {
     // Business cloud workspace: the model loop stays on the backend and every
     // file/bash tool call relays here, executing on the business EC2 via the
@@ -1781,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;
@@ -1878,10 +2035,15 @@ 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();
+  const turnId = options.turnId || createTurnId();
   const shouldSendConnectionContext = options.connectionContext
     || route === 'cloud'
     || mentionsConnector(message)
@@ -1890,13 +2052,17 @@ async function postTurn(message, options = {}) {
     ? await buildConnectionContext({ token, localWorkspace: local })
     : null);
   const connectionUserId = !local && isLoopbackBackend({ route: endpointRoute }) ? authUserId() : '';
-  const payload = buildPayload(message, { ...options, route, connectionContext, connectionUserId });
+  const payload = buildPayload(message, { ...options, route, connectionContext, connectionUserId, turnId });
   const postData = JSON.stringify(payload);
   const output = options.output || process.stdout;
   // 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 = {
@@ -2266,10 +2432,19 @@ 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 result = await turnFunction(trimmed, { mode, cwd, history, output, route, business: options.business, verify: options.verify, conversationId });
+    const turnId = options.turnId || createTurnId();
+    const result = await turnFunction(trimmed, { mode, cwd, history, output, route, business: options.business, verify: options.verify, conversationId, turnId });
     if (result.output && !result.output.endsWith('\n')) output.write('\n');
     const approvalExecution = normalizeMode(mode) === 'code-fast'
       ? null
@@ -2331,7 +2506,7 @@ function printBackendHint(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}`;
+  return `cd ${process.env.HOME}/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 formatBackendHint(options = {}) {
@@ -3219,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);
   }
 }