atris 3.34.0 → 3.36.0

package/lib/self-drive.js

@@ -0,0 +1,258 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const HUMAN_BLOCKING_REASONS = new Set(['auth-required', 'model-unavailable', 'rate-limit-exceeded-wall']);
+const OPEN_TASK_STATUSES = new Set(['open', 'claimed', 'review']);
+
+const SWARLO_HUB = process.env.SWARLO_HUB_URL || process.env.SWARLO_HUB || 'http://localhost:8090';
+const SWARLO_HUB_ID = process.env.SWARLO_HUB_ID || 'atris';
+const SWARLO_FLEET_TIMEOUT_MS = 3000;
+const SWARLO_ESCALATIONS_CHANNEL = 'escalations';
+
+function loadSwarloApiKey() {
+  if (process.env.SWARLO_API_KEY) return process.env.SWARLO_API_KEY;
+  const keyDir = path.join(require('os').homedir(), '.swarlo');
+  let files;
+  try {
+    // Newest key first: the hub DB rotates and old keys 401, so mtime beats
+    // lexicographic order (live repro 2026-07-10: first-sorted key was dead,
+    // the most recently minted one was valid).
+    files = fs.readdirSync(keyDir)
+      .filter((name) => name.endsWith('.key'))
+      .map((name) => {
+        const full = path.join(keyDir, name);
+        let mtime = 0;
+        try { mtime = fs.statSync(full).mtimeMs; } catch (error) { /* skip */ }
+        return { full, mtime };
+      })
+      .sort((a, b) => b.mtime - a.mtime);
+  } catch (error) {
+    return null;
+  }
+  if (!files.length) return null;
+  const key = fs.readFileSync(files[0].full, 'utf8').trim();
+  return key || null;
+}
+
+// Default synchronous HTTP transport: shells out to curl so this stays
+// callable from handleMissionBlocker without turning it into an async fn
+// (existing callers in commands/mission.js read the return value inline).
+function curlPost(url, { headers, body, timeoutMs }) {
+  const { spawnSync } = require('child_process');
+  const args = ['-sS', '-o', '-', '-w', '\n%{http_code}', '--max-time', String(Math.ceil(timeoutMs / 1000)), '-X', 'POST'];
+  for (const [key, value] of Object.entries(headers || {})) {
+    args.push('-H', `${key}: ${value}`);
+  }
+  args.push('-d', body, url);
+  const result = spawnSync('curl', args, { encoding: 'utf8' });
+  if (result.error || result.status !== 0) {
+    return { ok: false, status: 0, body: '' };
+  }
+  const output = result.stdout || '';
+  const lastNewline = output.lastIndexOf('\n');
+  const statusCode = Number(output.slice(lastNewline + 1).trim());
+  const responseBody = lastNewline >= 0 ? output.slice(0, lastNewline) : '';
+  return { ok: statusCode >= 200 && statusCode < 300, status: statusCode, body: responseBody };
+}
+
+function postBlockerToFleet({ task, blockerClass, stopReason, mission }, injected = {}) {
+  const loadKey = injected.loadSwarloApiKey || loadSwarloApiKey;
+  const httpPost = injected.httpPost || curlPost;
+  const channel = SWARLO_ESCALATIONS_CHANNEL;
+  try {
+    const apiKey = loadKey();
+    if (!apiKey) return { posted: false, channel };
+    const ref = taskRef(task);
+    const content = `Mission blocker filed with no local engine ready: ${ref} — ${String(stopReason || blockerClass).trim()}. Mission: ${String(mission?.objective || mission?.id || '').trim()}.`;
+    const response = httpPost(`${SWARLO_HUB}/api/${SWARLO_HUB_ID}/channels/${channel}/posts`, {
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({ content, kind: 'alert', task_key: ref }),
+      timeoutMs: SWARLO_FLEET_TIMEOUT_MS,
+    });
+    if (!response || !response.ok) return { posted: false, channel };
+    return { posted: true, channel };
+  } catch (error) {
+    return { posted: false, channel };
+  }
+}
+
+function reasonClass(value) {
+  const reason = String(value || 'blocked').trim().toLowerCase();
+  return reason.replace(/\s+/g, '-').slice(0, 120) || 'blocked';
+}
+
+function clipPlainClause(value, max) {
+  const plain = String(value || '')
+    .replace(/["'“”‘’]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .replace(/[.!?]+$/, '');
+  if (plain.length <= max) return plain;
+  const clipped = plain.slice(0, max + 1);
+  const boundary = clipped.lastIndexOf(' ');
+  return clipped.slice(0, boundary > 0 ? boundary : max).trim();
+}
+
+function shortObjectiveClause(value) {
+  const plain = String(value || '')
+    .replace(/["'“”‘’]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+  const boundary = plain.search(/:|[.!?](?=\s|$)/);
+  const clause = boundary > 0 ? plain.slice(0, boundary) : plain;
+  return clause.charAt(0).toLowerCase() + clause.slice(1);
+}
+
+function plainStopReason(value) {
+  const raw = String(value || 'blocked').trim().toLowerCase();
+  const repeated = /^repeated[-_ ]+error\s*[:/ -]*/.test(raw);
+  const plain = raw
+    .replace(/^repeated[-_ ]+error\s*[:/ -]*/, '')
+    .replace(/["'“”‘’]/g, '')
+    .replace(/[_:/-]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim() || 'blocked';
+  return repeated ? `${plain} repeatedly` : plain;
+}
+
+function missionBlockerTitle(objective, stopReason) {
+  const max = 80;
+  const fixedLength = 'get '.length + ' moving again: '.length;
+  const objectiveClause = shortObjectiveClause(objective) || 'mission';
+  const reasonClause = plainStopReason(stopReason);
+  const shortObjective = clipPlainClause(objectiveClause, max - fixedLength - 16);
+  const shortReason = clipPlainClause(reasonClause, max - fixedLength - shortObjective.length);
+  return `get ${shortObjective} moving again: ${shortReason}`;
+}
+
+function taskRef(task) {
+  return task?.display_id || task?.legacy_ref || task?.id || null;
+}
+
+function defaultDependencies() {
+  const taskDb = require('./task-db');
+  return {
+    taskDb,
+    resolveEngineForRole: require('./engine-registry').resolveEngineForRole,
+    dispatchToEngine: require('./fleet').dispatchToEngine,
+    createAgentWorktree: require('../commands/worktree').createAgentWorktree,
+  };
+}
+
+function projectTasks(taskDb, db, workspaceRoot) {
+  if (typeof taskDb.taskProjection !== 'function') return;
+  const file = path.join(workspaceRoot, '.atris', 'state', 'tasks.projection.json');
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(taskDb.taskProjection(db, { workspaceRoot, limit: 500 }), null, 2)}\n`);
+}
+
+function handleMissionBlocker({ mission, stopReason, workspaceRoot, appendEvent }, injected = {}) {
+  if (!mission || !mission.id) return { taskId: null, dispatched: false, engine: null, reason: 'missing mission' };
+  const blockerClass = reasonClass(stopReason || mission.stop_reason || mission.last_tick_reason);
+  if (HUMAN_BLOCKING_REASONS.has(blockerClass) || (Array.isArray(mission.human_asks) && mission.human_asks.length)) {
+    return { taskId: null, dispatched: false, engine: null, reason: 'human-blocking' };
+  }
+  if (['ready', 'complete'].includes(String(mission.status || '').toLowerCase())) {
+    return { taskId: null, dispatched: false, engine: null, reason: 'stop condition met' };
+  }
+
+  const deps = { ...defaultDependencies(), ...injected };
+  const root = path.resolve(workspaceRoot || process.cwd());
+  const db = deps.taskDb.open();
+  const scopedRoot = deps.taskDb.workspaceRoot ? deps.taskDb.workspaceRoot(root) : root;
+  const rows = deps.taskDb.withTaskDisplayRefs(deps.taskDb.listTasks(db, { workspaceRoot: scopedRoot }));
+  const matching = rows.filter((row) => row.metadata?.mission_id === mission.id
+    && row.metadata?.mission_blocker_class === blockerClass);
+  const existing = matching.find((row) => OPEN_TASK_STATUSES.has(row.status));
+  let task = existing;
+
+  if (task) {
+    return { taskId: taskRef(task), dispatched: false, engine: null, reason: 'existing blocker task' };
+  }
+
+  if (!task) {
+    const evidence = String(mission.receipt_path || mission.last_tick_reason || stopReason || blockerClass).trim();
+    const objective = String(mission.objective || mission.id).trim();
+    const fullStopReason = String(stopReason || blockerClass).trim();
+    const title = missionBlockerTitle(objective, fullStopReason);
+    const created = deps.taskDb.addTask(db, {
+      title,
+      tag: 'mission-blocker',
+      workspaceRoot: scopedRoot,
+      sourceKey: `mission-blocker:${mission.id}:${blockerClass}:${matching.length}`,
+      metadata: {
+        mission_id: mission.id,
+        mission_objective: objective,
+        mission_blocker_class: blockerClass,
+        stop_reason: fullStopReason,
+        evidence,
+      },
+    });
+    const refreshed = deps.taskDb.withTaskDisplayRefs(deps.taskDb.listTasks(db, { workspaceRoot: scopedRoot }));
+    task = refreshed.find((row) => row.id === created.id) || deps.taskDb.getTask(db, created.id);
+    if (created.inserted !== false && task && typeof deps.taskDb.noteTask === 'function') {
+      deps.taskDb.noteTask(db, {
+        id: task.id,
+        actor: 'self-drive',
+        content: `Mission objective: ${objective}\nStop reason: ${fullStopReason}\nEvidence: ${evidence}`,
+      });
+    }
+    projectTasks(deps.taskDb, db, scopedRoot);
+    if (created.inserted === false) {
+      return { taskId: taskRef(task), dispatched: false, engine: null, reason: 'existing blocker task' };
+    }
+    if (created.inserted !== false) {
+      appendEvent?.('mission_blocker_task_filed', {
+        task_id: taskRef(task),
+        stop_reason: String(stopReason || blockerClass),
+        blocker_class: blockerClass,
+      });
+    }
+  }
+
+  const ref = taskRef(task);
+  const engine = deps.resolveEngineForRole('executor', scopedRoot);
+  if (!engine) {
+    const fleet = postBlockerToFleet({ task, blockerClass, stopReason, mission }, injected);
+    if (fleet.posted) {
+      appendEvent?.('mission_blocker_fleet_escalated', {
+        task_id: ref,
+        blocker_class: blockerClass,
+        channel: fleet.channel,
+      });
+      return { taskId: ref, dispatched: false, engine: null, fleet_posted: true, reason: 'no ready executor engine; escalated to fleet' };
+    }
+    return { taskId: ref, dispatched: false, engine: null, fleet_posted: false, reason: 'no ready executor engine' };
+  }
+
+  try {
+    if (task.status === 'open' && typeof deps.taskDb.claimTask === 'function') {
+      const claim = deps.taskDb.claimTask(db, { id: task.id, claimedBy: `fleet-${engine.id}` });
+      if (!claim.claimed) return { taskId: ref, dispatched: false, engine: null, reason: 'existing blocker task' };
+      task = { ...task, ...claim.row };
+    }
+    const worktree = deps.createAgentWorktree({
+      root: scopedRoot,
+      agent: engine.id,
+      task: `mission-blocker-${String(ref).toLowerCase()}`,
+    });
+    deps.dispatchToEngine({ task, engine: engine.id, worktreePath: worktree.path, root: scopedRoot });
+    projectTasks(deps.taskDb, db, scopedRoot);
+    appendEvent?.('mission_blocker_dispatched', {
+      task_id: ref,
+      engine: engine.id,
+      blocker_class: blockerClass,
+      worktree_path: worktree.path,
+    });
+    return { taskId: ref, dispatched: true, engine: engine.id, reason: 'dispatched' };
+  } catch (error) {
+    return { taskId: ref, dispatched: false, engine: engine.id, reason: error.message || String(error) };
+  }
+}
+
+module.exports = { handleMissionBlocker };

package/lib/short-name.js

@@ -0,0 +1,103 @@
+'use strict';
+
+const FILLER_WORDS = new Set([
+  'a',
+  'an',
+  'and',
+  'are',
+  'as',
+  'at',
+  'be',
+  'by',
+  'claim',
+  'for',
+  'from',
+  'in',
+  'is',
+  'of',
+  'on',
+  'or',
+  'please',
+  'pls',
+  'that',
+  'the',
+  'these',
+  'this',
+  'those',
+  'to',
+  'via',
+  'with',
+]);
+
+function displayNumber(value) {
+  const number = Number(value);
+  return Number.isInteger(number) && number > 0 ? number : 0;
+}
+
+function nextRecordNumber(records = []) {
+  const assigned = new Set();
+  const max = records.reduce((largest, record) => {
+    const number = displayNumber(record && record.n);
+    if (!number) return largest;
+    const id = String(record && record.id || '').trim();
+    if (id && assigned.has(id)) return largest;
+    if (id) assigned.add(id);
+    return Math.max(largest, number);
+  }, 0);
+  return max + 1;
+}
+
+function shortId(id) {
+  const text = String(id || '').trim();
+  if (!text) return 'unknown';
+  return text.length <= 8 ? text : text.slice(-8);
+}
+
+function meaningfulWords(text, limit = 3) {
+  const words = String(text || '')
+    .toLowerCase()
+    .match(/[a-z0-9][a-z0-9']*/g) || [];
+  return words
+    .filter((word) => !FILLER_WORDS.has(word))
+    .slice(0, limit);
+}
+
+function shortRecordLabel(record, text, options = {}) {
+  const number = displayNumber(record && record.n);
+  const words = meaningfulWords(text, options.wordLimit || 3);
+  if (!number) {
+    return words.length ? words.join(' ') : shortId(record && record.id);
+  }
+  const suffix = words.length ? ` ${words.join(' ')}` : '';
+  return `#${number}${suffix}`;
+}
+
+function shortRecordRef(record) {
+  const number = displayNumber(record && record.n);
+  return number ? String(number) : shortId(record && record.id);
+}
+
+function recordMatchesRef(record, ref, options = {}) {
+  if (!record) return false;
+  const raw = String(ref || '').trim();
+  if (!raw) return false;
+  const withoutHash = raw.startsWith('#') ? raw.slice(1) : raw;
+  const wantedNumber = displayNumber(withoutHash);
+  if (wantedNumber) return displayNumber(record.n) === wantedNumber;
+  const id = String(record.id || '').trim();
+  if (!id) return false;
+  if (id === raw || id === withoutHash) return true;
+  if (options.prefix !== false && (id.startsWith(raw) || id.startsWith(withoutHash))) return true;
+  if (options.suffix !== false && (id.endsWith(raw) || id.endsWith(withoutHash))) return true;
+  return false;
+}
+
+module.exports = {
+  displayNumber,
+  meaningfulWords,
+  nextRecordNumber,
+  recordMatchesRef,
+  shortId,
+  shortRecordLabel,
+  shortRecordRef,
+};

package/lib/spawn-env.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const path = require('path');
+
+// Autonomously launched runtimes (cron, launchd, pulse ticks) carry a minimal
+// PATH without node's directory, so any shell command that may invoke
+// `node ...` fails only in the one environment nobody is watching. Three
+// subsystems hit this on 2026-07-07 alone (experiment applies, atris2 relayed
+// ops, always-on mission verifiers). Prepend the directory of the node that
+// runs this CLI before spawning shell commands from autonomous paths.
+function envWithNodeDir(base = process.env) {
+  const nodeDir = path.dirname(process.execPath);
+  const basePath = String(base.PATH || '');
+  if (basePath.split(path.delimiter).includes(nodeDir)) return base;
+  return { ...base, PATH: `${nodeDir}${path.delimiter}${basePath}` };
+}
+
+module.exports = { envWithNodeDir };

package/lib/state-detection.js

@@ -185,6 +185,60 @@ function getTaskCounts(atrisDir) {
   };
 }
 
+// One read of the task source returning counts plus a few actual titles, so
+// boot surfaces can show the work itself instead of just numbers.
+// Same source rules as getTaskCounts: DB wins, TODO.md is the fallback,
+// and nothing here may create a DB that doesn't exist.
+function getTaskGlance(atrisDir, sampleSize = 3) {
+  try {
+    const taskDb = require('./task-db');
+    if (fs.existsSync(taskDb.getDbPath())) {
+      const workspaceRoot = taskDb.workspaceRoot(path.dirname(path.resolve(atrisDir)));
+      const rows = taskDb.listTasks(taskDb.open(), { workspaceRoot, limit: 500 });
+      if (rows.length) {
+        const glance = {
+          backlog: 0, active: 0, review: 0, reviewCertified: 0,
+          activeTitles: [], backlogTitles: [], certifiedTitles: [], source: 'db'
+        };
+        for (const row of rows) {
+          const status = String(row.status || '').toLowerCase();
+          if (TASK_STATUS_BUCKETS.backlog.has(status)) {
+            glance.backlog++;
+            if (row.title && glance.backlogTitles.length < sampleSize) glance.backlogTitles.push(row.title);
+          } else if (TASK_STATUS_BUCKETS.inProgress.has(status)) {
+            glance.active++;
+            if (row.title && glance.activeTitles.length < sampleSize) glance.activeTitles.push(row.title);
+          } else if (TASK_STATUS_BUCKETS.review.has(status)) {
+            glance.review++;
+            try {
+              const meta = typeof row.metadata === 'string' ? JSON.parse(row.metadata || '{}') : (row.metadata || {});
+              if (meta.agent_certified && meta.approval_status !== 'accepted') {
+                glance.reviewCertified++;
+                if (row.title && glance.certifiedTitles.length < sampleSize) glance.certifiedTitles.push(row.title);
+              }
+            } catch { /* unreadable metadata - count as uncertified */ }
+          }
+        }
+        return glance;
+      }
+    }
+  } catch (e) {
+    if (process.env.ATRIS_DEBUG) console.error('[state-detection] db glance read failed:', e.message);
+  }
+  const backlogTitles = getBacklogTasks(atrisDir);
+  const activeTitles = getInProgressTasks(atrisDir);
+  return {
+    backlog: backlogTitles.length,
+    active: activeTitles.length,
+    review: 0,
+    reviewCertified: 0,
+    activeTitles: activeTitles.slice(0, sampleSize),
+    backlogTitles: backlogTitles.slice(0, sampleSize),
+    certifiedTitles: [],
+    source: 'todo'
+  };
+}
+
 function getTodayInboxItems(workspaceDir) {
   const atrisDir = path.join(workspaceDir, 'atris');
   const logsDir = path.join(atrisDir, 'logs');
@@ -357,5 +411,6 @@ module.exports = {
   getBacklogTasks,
   getInProgressTasks,
   getCompletedTasks,
-  getTaskCounts
+  getTaskCounts,
+  getTaskGlance
 };

package/lib/sync-status.js

@@ -0,0 +1,59 @@
+const fs = require('fs');
+const path = require('path');
+const { loadManifest, computeLocalHashes, filterSyncFiles } = require('./manifest');
+
+/**
+ * Count files whose local hash differs from the last-synced manifest.
+ * A path present on only one side (new local, deleted since sync) counts as
+ * drifted. Pure function so it is unit-testable without touching disk.
+ */
+function driftCount(localFiles = {}, manifest = null) {
+  const local = filterSyncFiles(localFiles);
+  const base = filterSyncFiles(manifest && manifest.files ? manifest.files : {});
+  const paths = new Set([...Object.keys(local), ...Object.keys(base)]);
+  let drifted = 0;
+  for (const p of paths) {
+    const l = local[p] ? local[p].hash : null;
+    const b = base[p] ? base[p].hash : null;
+    if (l !== b) drifted += 1;
+  }
+  return drifted;
+}
+
+/**
+ * Resolve the configured cloud business slug for a workspace, or null.
+ */
+function readBusinessSlug(root) {
+  const bizFile = path.join(root, '.atris', 'business.json');
+  if (!fs.existsSync(bizFile)) return null;
+  try {
+    const biz = JSON.parse(fs.readFileSync(bizFile, 'utf8'));
+    return biz.slug || biz.name || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * One-line cloud sync status for the boot surface. Local-only, never blocks:
+ *   - "offline"        no cloud business configured or never synced
+ *   - "in sync"        every synced file matches the manifest
+ *   - "N files drifted" N local files differ from the last sync
+ */
+function syncStatus(root = process.cwd()) {
+  const slug = readBusinessSlug(root);
+  if (!slug) return 'offline';
+  const manifest = loadManifest(slug);
+  if (!manifest) return 'offline';
+  let localFiles;
+  try {
+    localFiles = computeLocalHashes(root);
+  } catch {
+    return 'offline';
+  }
+  const n = driftCount(localFiles, manifest);
+  if (n === 0) return 'in sync';
+  return `${n} file${n === 1 ? '' : 's'} drifted`;
+}
+
+module.exports = { driftCount, readBusinessSlug, syncStatus };