atris 3.34.0 → 3.36.0

package/lib/task-receipt.js

@@ -0,0 +1,93 @@
+'use strict';
+
+// Receipt writer for task proofs. Mirrors the mission receipt shape
+// (commands/mission.js writeReceipt) so lib/receipt-evidence.js can validate
+// paths named in a proof at the review gate: schema tag, `at` timestamp,
+// result.passed. Every call writes a receipt file, pass or fail — a failing
+// verifier still leaves a record, it just can't be cited to move a task to
+// ready.
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+function tailText(text, max = 400) {
+  const trimmed = String(text || '').trim();
+  if (trimmed.length <= max) return trimmed;
+  return `...${trimmed.slice(-max)}`;
+}
+
+function gitCommitHash(root) {
+  try {
+    const result = spawnSync('git', ['rev-parse', 'HEAD'], { cwd: root, encoding: 'utf8' });
+    if (result.status === 0) return String(result.stdout || '').trim() || null;
+  } catch {
+    // ignore — not every workspace is a git repo
+  }
+  return null;
+}
+
+function runsDir(root) {
+  return path.join(root, 'atris', 'runs');
+}
+
+function slugifyTaskId(taskId) {
+  return String(taskId || 'task')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 40) || 'task';
+}
+
+// Runs `command` for `taskId`, writes atris/runs/<date>-task-<id>-<time>.json,
+// and returns { ok, passed, receiptPath, exit, signal, output }. `ok` mirrors
+// `passed` — kept as a separate field so callers reading either name work.
+function writeTaskReceipt({ taskId, command, root = process.cwd(), runner } = {}) {
+  const cmd = String(command || '').trim();
+  if (!taskId) return { ok: false, passed: false, reason: 'task_id_required' };
+  if (!cmd) return { ok: false, passed: false, reason: 'verify_command_required' };
+  const run = runner || spawnSync;
+  const result = run('bash', ['-lc', cmd], {
+    cwd: root,
+    encoding: 'utf8',
+    timeout: 120000,
+  });
+  if (result.error) {
+    return { ok: false, passed: false, reason: 'verifier_spawn_failed', error: result.error.message, cmd };
+  }
+  const output = tailText(`${result.stdout || ''}${result.stderr || ''}`);
+  const passed = result.status === 0;
+  const dir = runsDir(root);
+  fs.mkdirSync(dir, { recursive: true });
+  const now = new Date();
+  const date = now.toISOString().slice(0, 10);
+  const safeTime = now.toISOString().replace(/[:.]/g, '-');
+  const receiptFile = path.join(dir, `${date}-task-${slugifyTaskId(taskId)}-${safeTime}.json`);
+  const receiptPath = path.relative(root, receiptFile);
+  const receipt = {
+    schema: 'atris.task_receipt.v1',
+    task_id: String(taskId),
+    command: cmd,
+    at: now.toISOString(),
+    commit: gitCommitHash(root),
+    result: {
+      passed,
+      exit: result.status,
+      signal: result.signal || null,
+      output,
+    },
+  };
+  fs.writeFileSync(receiptFile, JSON.stringify(receipt, null, 2) + '\n', 'utf8');
+  return {
+    ok: passed,
+    passed,
+    receiptPath,
+    receiptFile,
+    exit: result.status,
+    signal: result.signal || null,
+    output,
+    cmd,
+  };
+}
+
+module.exports = { writeTaskReceipt };

package/lib/team-presence.js

@@ -0,0 +1,260 @@
+'use strict';
+
+const DEFAULT_FRESHNESS_WINDOW_MS = 15 * 60 * 1000;
+const ACTIVE_TASK_STATES = new Set(['claimed', 'do', 'doing', 'in_progress', 'review']);
+const ACTIVE_MISSION_STATES = new Set(['planning', 'active', 'running', 'ready']);
+
+function timestampMs(value) {
+  if (value == null || value === '') return 0;
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value)) return 0;
+    return value > 1000000000000 ? value : value * 1000;
+  }
+  const numeric = Number(value);
+  if (Number.isFinite(numeric) && String(value).trim() !== '') return timestampMs(numeric);
+  const parsed = Date.parse(String(value));
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function latestTimestamp(...values) {
+  return values.reduce((latest, value) => Math.max(latest, timestampMs(value)), 0);
+}
+
+function isoTimestamp(value) {
+  const ms = timestampMs(value);
+  return ms ? new Date(ms).toISOString() : null;
+}
+
+function memberName(value) {
+  let text = String(value || '').trim();
+  if (!text) return '';
+  if (text.includes('/')) text = text.split('/')[0];
+  text = text.replace(/[^A-Za-z0-9_.-]+/g, '-').replace(/^-+|-+$/g, '');
+  if (!text || /^(team|unknown)$/i.test(text)) return '';
+  return text.slice(0, 32);
+}
+
+function operatorSentence(value, fallback = 'current activity was recorded') {
+  let text = String(value || '')
+    .split(/\r?\n/)
+    .map((line) => line.trim().replace(/^[-*]\s+/, ''))
+    .find(Boolean) || fallback;
+  text = text
+    .replace(/(^|\s)--[a-z0-9][a-z0-9-]*(?:=[^\s]+)?/ig, '$1')
+    .replace(/\b[0-9A-HJKMNP-TV-Z]{20,26}\b/g, 'the item')
+    .replace(/\b[A-Z]{2,12}-\d+\b/gi, 'the task')
+    .replace(/\bmission-[a-z0-9][a-z0-9-]{8,}\b/ig, 'the mission')
+    .replace(/\s+/g, ' ')
+    .trim();
+  if (!text) text = fallback;
+  if (text.length > 180) text = `${text.slice(0, 177).trim()}...`;
+  if (!/[.!?]$/.test(text)) text += '.';
+  return text;
+}
+
+function taskOwner(task) {
+  return task && (task.claimed_by || task.assigned_to || task.metadata?.assigned_to) || '';
+}
+
+function taskActivityMs(task) {
+  const events = Array.isArray(task?.events) ? task.events : [];
+  return latestTimestamp(
+    task?.updated_at,
+    task?.created_at,
+    ...events.map((event) => event && event.created_at),
+  );
+}
+
+function missionActivityMs(mission) {
+  return latestTimestamp(
+    mission?.last_tick_at,
+    mission?.last_tick?.finished_at,
+    mission?.last_tick?.at,
+    mission?.updated_at,
+    mission?.created_at,
+  );
+}
+
+function activityOrder(a, b, activityFn) {
+  return activityFn(b) - activityFn(a)
+    || String(a.id || a.title || a.objective || '').localeCompare(String(b.id || b.title || b.objective || ''));
+}
+
+function taskRows(input) {
+  if (Array.isArray(input.tasks)) return input.tasks;
+  if (Array.isArray(input.taskStatus?.tasks)) return input.taskStatus.tasks;
+  if (Array.isArray(input.taskStatus?.streams)) {
+    return input.taskStatus.streams.flatMap((stream) => Array.isArray(stream.tasks) ? stream.tasks : []);
+  }
+  return [input.taskStatus?.current].filter(Boolean);
+}
+
+function missionRows(input) {
+  if (Array.isArray(input.missions)) return input.missions;
+  if (Array.isArray(input.missionStatus?.missions)) return input.missionStatus.missions;
+  return [];
+}
+
+function loopMissionName(mission) {
+  const raw = mission?.name || mission?.title || mission?.objective || mission?.id || 'mission';
+  return operatorSentence(raw, 'mission').replace(/[.!?]+$/, '').slice(0, 90);
+}
+
+function loopForMission(mission) {
+  if (!mission) return null;
+  const lastTick = isoTimestamp(
+    mission.last_tick_at
+      || mission.last_tick?.finished_at
+      || mission.last_tick?.at,
+  );
+  return {
+    mission: loopMissionName(mission),
+    cadence: String(mission.cadence || 'manual'),
+    runner: String(mission.runner || mission.executed_by || 'manual'),
+    last_tick: lastTick || 'never',
+  };
+}
+
+function streamActiveRows(stream) {
+  return (Array.isArray(stream?.active) ? stream.active : []).map((row) => {
+    if (Array.isArray(row)) return { name: row[0], summary: row[1], last_seen: row[2] };
+    return {
+      name: row?.name || row?.agent || row?.member,
+      summary: row?.summary || row?.doing || row?.work,
+      last_seen: row?.last_seen || row?.ts || row?.at,
+    };
+  });
+}
+
+function buildTeamPresence(input = {}) {
+  const nowMs = timestampMs(input.nowMs ?? input.now ?? Date.now()) || Date.now();
+  const freshnessWindowMs = Number(input.freshnessWindowMs) > 0
+    ? Number(input.freshnessWindowMs)
+    : DEFAULT_FRESHNESS_WINDOW_MS;
+  const stream = input.stream || input.streamSnapshot || {};
+  const events = Array.isArray(input.streamEvents)
+    ? input.streamEvents
+    : Array.isArray(input.events) ? input.events : [];
+  const tasks = taskRows(input).filter(Boolean);
+  const missions = missionRows(input).filter(Boolean);
+  const candidates = new Map();
+  const lastSeen = new Map();
+  const summaries = new Map();
+  const tasksByMember = new Map();
+  const missionsByMember = new Map();
+
+  const keyFor = (value) => memberName(value).toLowerCase();
+  const addCandidate = (value) => {
+    const name = memberName(value);
+    const key = name.toLowerCase();
+    if (!key) return '';
+    if (!candidates.has(key)) candidates.set(key, name);
+    return key;
+  };
+  const noteSeen = (value, timestamp) => {
+    const key = keyFor(value);
+    const ms = timestampMs(timestamp);
+    if (!key || !ms) return;
+    lastSeen.set(key, Math.max(lastSeen.get(key) || 0, ms));
+  };
+
+  for (const event of events) {
+    noteSeen(event?.agent || event?.member || event?.owner, event?.ms || event?.ts || event?.at || event?.created_at);
+  }
+
+  for (const row of streamActiveRows(stream)) {
+    const key = addCandidate(row.name);
+    if (!key) continue;
+    if (row.summary) summaries.set(key, row.summary);
+    noteSeen(row.name, row.last_seen);
+  }
+
+  for (const task of tasks) {
+    if (!ACTIVE_TASK_STATES.has(String(task.status || '').toLowerCase())) continue;
+    const owner = taskOwner(task);
+    const key = addCandidate(owner);
+    if (!key) continue;
+    noteSeen(owner, taskActivityMs(task));
+    if (!tasksByMember.has(key)) tasksByMember.set(key, []);
+    tasksByMember.get(key).push(task);
+  }
+
+  for (const mission of missions) {
+    if (!ACTIVE_MISSION_STATES.has(String(mission.status || '').toLowerCase())) continue;
+    const owner = mission.owner || mission.member;
+    const key = addCandidate(owner);
+    if (!key) continue;
+    noteSeen(owner, missionActivityMs(mission));
+    if (!missionsByMember.has(key)) missionsByMember.set(key, []);
+    missionsByMember.get(key).push(mission);
+  }
+
+  for (const rows of tasksByMember.values()) rows.sort((a, b) => activityOrder(a, b, taskActivityMs));
+  for (const rows of missionsByMember.values()) rows.sort((a, b) => activityOrder(a, b, missionActivityMs));
+
+  const cutoffMs = nowMs - freshnessWindowMs;
+  const members = [...candidates.entries()]
+    .sort((a, b) => a[1].localeCompare(b[1]))
+    .flatMap(([key, name]) => {
+      const seenMs = lastSeen.get(key) || 0;
+      if (seenMs < cutoffMs) return [];
+      const task = tasksByMember.get(key)?.[0] || null;
+      const mission = missionsByMember.get(key)?.[0] || null;
+      const doing = summaries.get(key)
+        || task?.title
+        || mission?.next_action
+        || mission?.objective;
+      return [{
+        name,
+        awake: true,
+        doing: operatorSentence(doing),
+        loop: loopForMission(mission),
+        last_seen: new Date(seenMs).toISOString(),
+      }];
+    });
+
+  return {
+    schema: 'atris.team_presence.v1',
+    generated_at: new Date(nowMs).toISOString(),
+    freshness_window_seconds: Math.round(freshnessWindowMs / 1000),
+    totals: {
+      awake: members.length,
+      waiting_operator: Math.max(0, Number(stream.waiting_operator) || 0),
+      landing_wait: Math.max(0, Number(stream.landing_wait) || 0),
+    },
+    members,
+  };
+}
+
+function renderTeamPresence(presence) {
+  const minutes = presence.freshness_window_seconds / 60;
+  const windowText = Number.isInteger(minutes) ? `${minutes} minute${minutes === 1 ? '' : 's'}` : `${presence.freshness_window_seconds} seconds`;
+  const lines = [
+    `team presence: ${presence.totals.awake} awake`,
+    `freshness window: ${windowText}`,
+    `waiting on operator: ${presence.totals.waiting_operator}`,
+    `landing wait: ${presence.totals.landing_wait}`,
+  ];
+  if (!presence.members.length) {
+    lines.push('awake roster: empty');
+    return lines.join('\n');
+  }
+  lines.push('awake roster:');
+  for (const member of presence.members) {
+    lines.push(`  ${member.name}: ${member.doing}`);
+    if (member.loop) {
+      lines.push(`    loop: ${member.loop.mission} [${member.loop.cadence} | ${member.loop.runner} | last tick ${member.loop.last_tick}]`);
+    }
+    lines.push(`    last seen: ${member.last_seen}`);
+  }
+  return lines.join('\n');
+}
+
+module.exports = {
+  ACTIVE_MISSION_STATES,
+  ACTIVE_TASK_STATES,
+  DEFAULT_FRESHNESS_WINDOW_MS,
+  buildTeamPresence,
+  operatorSentence,
+  renderTeamPresence,
+};

package/lib/tool-result-encode.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function encodeToolResult(result) {
+  return Buffer.from(JSON.stringify(result), 'utf8').toString('base64');
+}
+
+module.exports = { encodeToolResult };

package/lib/trust-tiers.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const HISTORY_FILES = [
+  path.join('.atris', 'state', 'career_xp_receipts.jsonl'),
+  path.join('.atris', 'state', 'scorecards.jsonl'),
+];
+
+const PASS_OUTCOMES = new Set(['accepted', 'approved', 'done', 'pass', 'passed', 'success', 'succeeded']);
+const FAIL_OUTCOMES = new Set(['bounced', 'fail', 'failed', 'rejected', 'revised', 'rework_requested']);
+
+function normalizedActor(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function rowActor(row) {
+  return normalizedActor(row?.claimed_by || row?.metadata?.executed_by);
+}
+
+function rowPassed(row) {
+  for (const value of [row?.passed, row?.verify_passed, row?.metadata?.verify_passed]) {
+    if (typeof value === 'boolean') return value;
+  }
+  const outcome = String(row?.outcome || row?.status || '').trim().toLowerCase();
+  if (PASS_OUTCOMES.has(outcome)) return true;
+  if (FAIL_OUTCOMES.has(outcome)) return false;
+  return null;
+}
+
+function rowTime(row) {
+  for (const value of [row?.accepted_at, row?.ts, row?.recorded_at, row?.created_at, row?.updated_at]) {
+    const parsed = Date.parse(value || '');
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return null;
+}
+
+function readHistory(root) {
+  const rows = [];
+  let sequence = 0;
+  for (const relative of HISTORY_FILES) {
+    let text;
+    try {
+      text = fs.readFileSync(path.join(root, relative), 'utf8');
+    } catch {
+      return null;
+    }
+    for (const line of text.split(/\r?\n/)) {
+      if (!line.trim()) continue;
+      let row;
+      try {
+        row = JSON.parse(line);
+      } catch {
+        return null;
+      }
+      if (!row || typeof row !== 'object' || Array.isArray(row)) return null;
+      rows.push({ row, sequence: sequence++, time: rowTime(row) });
+    }
+  }
+  return rows;
+}
+
+function computeTrustTier(actor, root = process.cwd()) {
+  const target = normalizedActor(actor);
+  if (!target) return 'probation';
+  const history = readHistory(root);
+  if (!history) return 'probation';
+
+  const outcomes = history
+    .filter(({ row }) => rowActor(row) === target)
+    .map((entry) => ({ ...entry, passed: rowPassed(entry.row) }))
+    .filter(({ passed }) => passed !== null)
+    .sort((a, b) => {
+      if (a.time !== null && b.time !== null && a.time !== b.time) return a.time - b.time;
+      if (a.time !== null && b.time === null) return 1;
+      if (a.time === null && b.time !== null) return -1;
+      return a.sequence - b.sequence;
+    })
+    .slice(-20);
+
+  const passed = outcomes.filter((outcome) => outcome.passed).length;
+  const passRate = outcomes.length ? passed / outcomes.length : 0;
+  if (outcomes.length >= 10 && passRate >= 0.9) return 'trusted';
+  if (outcomes.length >= 5 && passRate >= 0.7) return 'standard';
+  return 'probation';
+}
+
+module.exports = { computeTrustTier };

package/lib/usage.js

@@ -0,0 +1,107 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { knownCommands } = require('./known-commands');
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const USAGE_RELATIVE_PATH = path.join('.atris', 'state', 'usage.jsonl');
+const USAGE_MAX_BYTES = 5 * 1024 * 1024;
+
+// Usage telemetry used to write to `<cwd>/.atris/state/usage.jsonl`, so a
+// command run from a subdirectory that already had a nested .atris (e.g.
+// backend/) split its usage away from the workspace root's store — the same
+// footgun the mission and task stores hit. Resolve to the shared workspace
+// root (spine-first -> git toplevel -> cwd) so usage lands with the rest of the
+// state, whichever subdir the caller stood in. Falls back to the raw cwd if the
+// shared resolver can't load; telemetry must never break the command path.
+function resolveUsageRoot(cwd = process.cwd()) {
+  try {
+    const { workspaceRoot } = require('./task-db');
+    const root = workspaceRoot(cwd);
+    if (root) return root;
+  } catch {}
+  return cwd;
+}
+
+function usagePath(cwd = process.cwd()) {
+  return path.join(resolveUsageRoot(cwd), USAGE_RELATIVE_PATH);
+}
+
+function parseUsageLine(line) {
+  try {
+    const entry = JSON.parse(line);
+    if (!entry || typeof entry !== 'object') return null;
+    if (typeof entry.at !== 'string' || typeof entry.cmd !== 'string') return null;
+    return entry;
+  } catch {
+    return null;
+  }
+}
+
+function readAllUsage(cwd = process.cwd()) {
+  const file = usagePath(cwd);
+  try {
+    if (!fs.existsSync(file)) return [];
+  } catch {
+    return [];
+  }
+  const out = [];
+  try {
+    for (const line of fs.readFileSync(file, 'utf8').split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const entry = parseUsageLine(trimmed);
+      if (entry) out.push(entry);
+    }
+  } catch {
+    return [];
+  }
+  return out;
+}
+
+function readUsage(cwd = process.cwd(), options = {}) {
+  const entries = readAllUsage(cwd);
+  const sinceDays = Number(options.sinceDays);
+  if (!Number.isFinite(sinceDays) || sinceDays <= 0) return entries;
+  const now = options.now ? new Date(options.now).getTime() : Date.now();
+  const cutoff = now - sinceDays * DAY_MS;
+  return entries.filter((entry) => {
+    const at = Date.parse(entry.at);
+    return Number.isFinite(at) && at >= cutoff;
+  });
+}
+
+function trimUsageFile(cwd = process.cwd()) {
+  const file = usagePath(cwd);
+  const stat = fs.statSync(file);
+  if (stat.size <= USAGE_MAX_BYTES) return;
+  const cutoff = Date.now() - 30 * DAY_MS;
+  const kept = readAllUsage(cwd).filter((entry) => {
+    const at = Date.parse(entry.at);
+    return Number.isFinite(at) && at >= cutoff;
+  });
+  fs.writeFileSync(file, kept.map((entry) => JSON.stringify(entry)).join('\n') + (kept.length ? '\n' : ''), 'utf8');
+}
+
+function recordUsage(command, cwd = process.cwd()) {
+  try {
+    if (!command || !knownCommands.includes(command)) return;
+    const root = resolveUsageRoot(cwd);
+    // The sensor observes workspaces, it never creates them: recording into a
+    // resolved root with no .atris/ would litter pristine cwds (even `--help`).
+    if (!fs.existsSync(path.join(root, '.atris'))) return;
+    const file = usagePath(root);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.appendFileSync(file, `${JSON.stringify({ at: new Date().toISOString(), cmd: String(command) })}\n`, 'utf8');
+    trimUsageFile(root);
+  } catch {
+    // Usage telemetry must never affect the command path.
+  }
+}
+
+module.exports = {
+  usagePath,
+  recordUsage,
+  readUsage,
+};