atris 3.16.1 → 3.17.0

package/commands/now.js

@@ -1,5 +1,6 @@
 const fs = require('fs');
 const path = require('path');
+const { hasRenderedSections, isOpenSection } = require('../lib/todo-sections');
 
 const NOW_PATH = path.join('atris', 'now.md');
 const TASK_EPISODES_PATH = path.join('.atris', 'state', 'task_episodes.jsonl');
@@ -71,7 +72,8 @@ function countMatches(filePath, pattern) {
 function countOpenTodoItems(filePath) {
   if (!fs.existsSync(filePath)) return 0;
   const content = fs.readFileSync(filePath, 'utf8');
-  const hasRenderedSections = /^##\s+(Backlog|In Progress|Blocked|Completed)\s*$/m.test(content);
+  // Emoji-decorated headings ("## In Progress 🔄") handled by lib/todo-sections.
+  const rendered = hasRenderedSections(content);
   let section = null;
   let count = 0;
 
@@ -83,7 +85,7 @@ function countOpenTodoItems(filePath) {
     }
     const isTaskBullet = /^-\s+(?:\[[ ]\]\s+)?\*\*.+?\*\*/.test(line);
     if (!isTaskBullet) continue;
-    if (!hasRenderedSections || ['Backlog', 'In Progress'].includes(section)) {
+    if (!rendered || isOpenSection(section)) {
       count += 1;
     }
   }

package/commands/probe.js

@@ -57,7 +57,10 @@ function normalizeBash(cmd, label) {
   return cmd.split(l + '/').join('').split(l).join('.');
 }
 
-// Probe is read-only: no write/edit file ops.
+// No write/edit file ops, and the `..` guard only covers args.path. The
+// `bash` op still executes whatever command the model sends, verbatim, on
+// the remote ai-computer — that is the production relay contract and the
+// table must stay in lockstep with it, so this probe is NOT read-only.
 function fileOpCommand(args, label) {
   const op = String(args.type || '').toLowerCase();
   const raw = normalizePath(String(args.path || '') || '.', label);
@@ -116,7 +119,9 @@ function atrisCliCommand(args) {
 }
 
 function atrisCliResult(command, term) {
-  const code = term.exit_code || 0;
+  // a terminal response without a numeric exit_code is a broken endpoint,
+  // not a success — never let it masquerade as ok with empty stdout
+  const code = typeof term.exit_code === 'number' ? term.exit_code : -1;
   const out = {
     schema: 'atris.local_cli_result.v1',
     status: code === 0 ? 'ok' : 'error',
@@ -124,7 +129,11 @@ function atrisCliResult(command, term) {
     stdout: String(term.stdout || '').slice(0, 12000),
     exit_code: code,
   };
-  if (code !== 0) out.error = String(term.stderr || term.stdout || 'command failed').slice(0, 2000);
+  if (code !== 0) {
+    out.error = typeof term.exit_code === 'number'
+      ? String(term.stderr || term.stdout || 'command failed').slice(0, 2000)
+      : 'terminal endpoint returned no exit_code';
+  }
   return out;
 }
 
@@ -154,7 +163,10 @@ function postJson(urlString, token, payload, timeoutMs) {
           reject(new Error(`HTTP ${res.statusCode}: ${data.slice(0, 200)}`));
           return;
         }
-        try { resolve(data ? JSON.parse(data) : {}); } catch (e) { resolve({}); }
+        if (!data) { resolve({}); return; }
+        try { resolve(JSON.parse(data)); } catch (e) {
+          reject(new Error(`invalid JSON from ${url.pathname}: ${data.slice(0, 120)}`));
+        }
       });
     });
     req.on('timeout', () => { req.destroy(new Error('request timeout')); });
@@ -188,35 +200,46 @@ function parseArgs(argv) {
   return a;
 }
 
-async function probeCommand(argv) {
-  const a = parseArgs(argv || []);
+// Core /atris2/turn client: one streamed turn over the full local tool relay.
+// Shared by `atris probe` (the instrument) and `atris mission run --runner atris2`
+// (the worker). Transport-level outcome only — callers apply their own
+// pass/fail policy on top of the returned fields.
+async function runAtris2Turn(opts = {}) {
+  const {
+    prompt,
+    model = 'atris:fast',
+    business = null,
+    memberId = null,
+    memberSlug = null,
+    maxTurns = 8,
+    idleMs = 180000,
+    connectTimeoutMs = 60000,
+    signal = null,
+  } = opts;
+  const t0 = Date.now();
+  const out = { ok: false, text: '', engine: null, tools_run: 0, cli_ops: [], unsupported: [], error: null, duration_ms: 0 };
   const creds = loadCredentials();
   if (!creds || !creds.token) {
-    console.error('✗ Not logged in. Run: atris login');
-    return 1;
+    out.error = 'not-logged-in';
+    out.duration_ms = Date.now() - t0;
+    return out;
   }
   const token = creds.token;
   const base = getApiBaseUrl();
-  const label = workspaceLabel(a.business);
-  const where = a.business ? `business ${String(a.business).slice(0, 8)}` : 'personal';
-  const member = a.memberSlug || a.memberId;
-  const prompt = a.message || (a.calendar
-    ? "What's on my calendar today? Use your tools."
-    : 'Read the first 5 lines of any markdown file in this workspace and quote one real line from it. Use your file tools.');
+  const label = workspaceLabel(business);
 
   const body = {
-    message: prompt, model: a.model, max_turns: 8,
+    message: prompt, model, max_turns: maxTurns,
     verify_command: 'true', local_executor: true, workspace_path: label,
   };
-  if (a.memberId) body.member_id = a.memberId;
-  if (a.memberSlug) body.member_slug = a.memberSlug;
+  if (memberId) body.member_id = memberId;
+  if (memberSlug) body.member_slug = memberSlug;
 
-  const t0 = Date.now();
   let toolsRun = 0;
-  let cliCalendarOps = 0;
   let resultText = '';
   let err = null;
   let engine = null;
+  const cliOps = [];
   const unsupported = [];
 
   try {
@@ -235,7 +258,11 @@ async function probeCommand(argv) {
           Accept: 'text/event-stream',
           Authorization: `Bearer ${token}`,
         },
+        // connect/first-byte guard; cleared once headers arrive so the
+        // idle timer below is the only judge of a flowing stream
+        timeout: connectTimeoutMs,
       }, (res) => {
+        req.setTimeout(0);
         if (res.statusCode < 200 || res.statusCode >= 300) {
           let data = '';
           res.on('data', (c) => data += c);
@@ -244,10 +271,9 @@ async function probeCommand(argv) {
         }
         let buffer = '';
         let idleTimer = null;
-        const IDLE_MS = 180000;
         const resetIdle = () => {
           if (idleTimer) clearTimeout(idleTimer);
-          idleTimer = setTimeout(() => { req.destroy(); reject(new Error(`stream stalled: no events for ${IDLE_MS / 1000}s`)); }, IDLE_MS);
+          idleTimer = setTimeout(() => { req.destroy(); reject(new Error(`stream stalled: no events for ${idleMs / 1000}s`)); }, idleMs);
         };
         resetIdle();
 
@@ -273,11 +299,16 @@ async function probeCommand(argv) {
                   out = { status: 'error', error: 'unsupported op or unsafe path' };
                   unsupported.push(`file_op:${op}`);
                 } else {
-                  const term = await runTerminal(base, token, cmd, a.business);
-                  const ok = (term.exit_code || 0) === 0;
+                  const term = await runTerminal(base, token, cmd, business);
+                  const ok = term.exit_code === 0;
                   out = ok
                     ? { status: 'ok', stdout: String(term.stdout || '').slice(0, 12000) }
-                    : { status: 'error', error: String(term.stderr || 'command failed').slice(0, 2000) };
+                    : {
+                        status: 'error',
+                        error: typeof term.exit_code === 'number'
+                          ? String(term.stderr || 'command failed').slice(0, 2000)
+                          : 'terminal endpoint returned no exit_code',
+                      };
                 }
               } else if (name === 'local_atris_cli_op') {
                 const cmd = atrisCliCommand(args);
@@ -285,9 +316,9 @@ async function probeCommand(argv) {
                   out = { status: 'error', error: `unsupported atris cli op: ${op || '?'}` };
                   unsupported.push(`cli_op:${op || '?'}`);
                 } else {
-                  const term = await runTerminal(base, token, cmd, a.business);
+                  const term = await runTerminal(base, token, cmd, business);
                   out = atrisCliResult(cmd, term);
-                  if (op.startsWith('calendar')) cliCalendarOps += 1;
+                  cliOps.push(op || '?');
                 }
               } else {
                 out = { status: 'error', error: `unsupported relayed tool: ${name || '?'}` };
@@ -321,7 +352,9 @@ async function probeCommand(argv) {
         });
         res.on('error', (e) => { if (idleTimer) clearTimeout(idleTimer); reject(e); });
       });
+      req.on('timeout', () => { req.destroy(new Error(`no response headers within ${Math.round(connectTimeoutMs / 1000)}s`)); });
       req.on('error', reject);
+      if (signal) signal.addEventListener('abort', () => { req.destroy(new Error('aborted')); }, { once: true });
       req.write(postData);
       req.end();
     });
@@ -329,6 +362,42 @@ async function probeCommand(argv) {
     if (!err) err = `${e.name || 'Error'}: ${e.message || e}`;
   }
 
+  out.text = resultText;
+  out.engine = engine;
+  out.tools_run = toolsRun;
+  out.cli_ops = cliOps;
+  out.unsupported = unsupported;
+  out.error = err;
+  out.ok = err === null;
+  out.duration_ms = Date.now() - t0;
+  return out;
+}
+
+async function probeCommand(argv) {
+  const a = parseArgs(argv || []);
+  const creds = loadCredentials();
+  if (!creds || !creds.token) {
+    console.error('✗ Not logged in. Run: atris login');
+    return 1;
+  }
+  const where = a.business ? `business ${String(a.business).slice(0, 8)}` : 'personal';
+  const member = a.memberSlug || a.memberId;
+  const prompt = a.message || (a.calendar
+    ? "What's on my calendar today? Use your tools."
+    : 'Read the first 5 lines of any markdown file in this workspace and quote one real line from it. Use your file tools.');
+
+  const t0 = Date.now();
+  const turn = await runAtris2Turn({
+    prompt, model: a.model, business: a.business,
+    memberId: a.memberId, memberSlug: a.memberSlug, maxTurns: 8,
+  });
+  const toolsRun = turn.tools_run;
+  const cliCalendarOps = turn.cli_ops.filter((op) => String(op).startsWith('calendar')).length;
+  const resultText = turn.text;
+  const err = turn.error;
+  const engine = turn.engine;
+  const unsupported = turn.unsupported;
+
   // Name the dead-end (first match wins); null = converged.
   let deadEnd = null;
   if (err) {
@@ -363,4 +432,13 @@ async function probeCommand(argv) {
   return ok ? 0 : 1;
 }
 
-module.exports = { probeCommand };
+module.exports = {
+  probeCommand,
+  runAtris2Turn,
+  // exported for tests
+  normalizePath,
+  normalizeBash,
+  fileOpCommand,
+  atrisCliCommand,
+  atrisCliResult,
+};