atris 3.35.0 → 3.37.0

package/lib/task-db.js

@@ -240,22 +240,43 @@ function newId() {
   return head + tail;
 }
 
-// Walk up from `start` to find the canonical workspace root. We check for
-// .git, then atris/, then .atris/. If none found, fall back to `start`. This
-// makes `atris task add` from a subdirectory write the same workspace_root
-// as parseTodo() reads from the project's atris/TODO.md.
+// Resolve the canonical workspace root so `atris task` from any subdirectory
+// keys the SAME store as the repo root. Precedence (nearest ancestor wins per
+// pass):
+//   1. A deliberate workspace spine — .atris/business.json (a bound customer
+//      sub-workspace) or atris/atris.md (the framework protocol file). These are
+//      intentional nested workspaces INSIDE a repo and must stay isolated.
+//   2. The git toplevel (.git). One git repo == one workspace; this rescues a
+//      subdirectory whose only markers are a bare atris/ or .atris/ dir.
+//   3. Legacy fallback for non-git trees: a bare atris/ or .atris/ dir.
+//
+// Before this, a bare atris/ or .atris/ dir short-circuited ahead of the git
+// root, so a subdir like backend/ (which has an atris/ folder plus a stray
+// .atris) hijacked itself as a second workspace root and split task/usage state
+// into backend/.atris (proven footgun 2026-07-16). Checking .git only at the
+// same level meant the walk returned before ever reaching the real repo root.
 function findWorkspaceRoot(start) {
-  let cur = path.resolve(start || process.cwd());
-  // Cap the walk at 32 levels to avoid pathological symlink loops.
-  for (let i = 0; i < 32; i++) {
-    if (fs.existsSync(path.join(cur, '.git'))) return cur;
-    if (fs.existsSync(path.join(cur, 'atris'))) return cur;
-    if (fs.existsSync(path.join(cur, '.atris'))) return cur;
-    const parent = path.dirname(cur);
-    if (parent === cur) break;
-    cur = parent;
-  }
-  return path.resolve(start || process.cwd());
+  const origin = path.resolve(start || process.cwd());
+  // Cap each walk at 32 levels to avoid pathological symlink loops.
+  const walkUp = (test) => {
+    let cur = origin;
+    for (let i = 0; i < 32; i++) {
+      if (test(cur)) return cur;
+      const parent = path.dirname(cur);
+      if (parent === cur) break;
+      cur = parent;
+    }
+    return null;
+  };
+  const spine = walkUp((dir) => fs.existsSync(path.join(dir, '.atris', 'business.json'))
+    || fs.existsSync(path.join(dir, 'atris', 'atris.md')));
+  if (spine) return spine;
+  const gitRoot = walkUp((dir) => fs.existsSync(path.join(dir, '.git')));
+  if (gitRoot) return gitRoot;
+  const legacy = walkUp((dir) => fs.existsSync(path.join(dir, 'atris'))
+    || fs.existsSync(path.join(dir, '.atris')));
+  if (legacy) return legacy;
+  return origin;
 }
 
 function workspaceRoot(cwd) {
@@ -558,17 +579,18 @@ function doneTask(db, { id, status, actor, allowReview = false, action, proof, a
 // (e.g. the 109 duplicate "Loop tick:" orphans fail-closed before 'archived'
 // existed — cluster 1 of failed-tasks-analysis-2026-07-03). It permits the
 // failed→archived transition and records the prior status in
-// metadata.archived_from. 'done' rows are never archivable: accepted work
-// stays done, with or without the flag.
-function archiveTask(db, { id, actor, reason, fromFailed = false } = {}) {
+// metadata.archived_from. Individual archive commands never archive 'done'
+// rows. The clear-done sweep opts in through fromDone after selecting only the
+// same 'done' rows counted by `atris status`.
+function archiveTask(db, { id, actor, reason, fromFailed = false, fromDone = false } = {}) {
   if (!id) throw new Error('id required');
   const reasonText = String(reason || '').trim();
   if (!reasonText) throw new Error('reason required');
   const row = getTask(db, id);
   if (!row) return { archived: false, reason: 'not_found' };
-  const allowedStatuses = fromFailed
-    ? ['open', 'claimed', 'review', 'failed']
-    : ['open', 'claimed', 'review'];
+  const allowedStatuses = ['open', 'claimed', 'review'];
+  if (fromFailed) allowedStatuses.push('failed');
+  if (fromDone) allowedStatuses.push('done');
   if (!allowedStatuses.includes(row.status)) {
     return { archived: false, reason: `already_${row.status}` };
   }
@@ -578,7 +600,8 @@ function archiveTask(db, { id, actor, reason, fromFailed = false } = {}) {
   metadata.archived_at = new Date(now).toISOString();
   metadata.archived_by = actor || process.env.ATRIS_AGENT_ID || process.env.USER || null;
   metadata.approval_status = 'archived';
-  if (row.status === 'failed') metadata.archived_from = 'failed';
+  if (row.status === 'failed' || row.status === 'done') metadata.archived_from = row.status;
+  const terminalAt = row.status === 'done' && row.done_at ? row.done_at : now;
   const statusPlaceholders = allowedStatuses.map(() => '?').join(', ');
   const result = withBusyRetry(() => db.prepare(`
     UPDATE tasks
@@ -588,7 +611,7 @@ function archiveTask(db, { id, actor, reason, fromFailed = false } = {}) {
            metadata = ?
      WHERE id = ?
        AND status IN (${statusPlaceholders})
-  `).run(now, now, JSON.stringify(metadata), id, ...allowedStatuses));
+  `).run(terminalAt, now, JSON.stringify(metadata), id, ...allowedStatuses));
   if (result.changes !== 1) return { archived: false, reason: 'stale_task_state' };
   const updated = getTask(db, id);
   const event = appendTaskEvent(db, {
@@ -596,7 +619,10 @@ function archiveTask(db, { id, actor, reason, fromFailed = false } = {}) {
     workspaceRoot: updated.workspace_root,
     actor: metadata.archived_by,
     eventType: 'archived',
-    payload: { reason: reasonText, ...(row.status === 'failed' ? { previous_status: 'failed' } : {}) },
+    payload: {
+      reason: reasonText,
+      ...(['failed', 'done'].includes(row.status) ? { previous_status: row.status } : {}),
+    },
   });
   const logs = appendTaskCompletionLogs(db, updated, {
     status: 'archived',
@@ -684,7 +710,7 @@ function recordReviewPassActor(metadata, claimedBy, rawActor) {
   return { builder: builder || null, independent };
 }
 
-function readyTask(db, { id, actor, proof, lesson, nextTask, landing = {}, resultTrace }) {
+function readyTask(db, { id, actor, proof, lesson, nextTask, landing = {}, resultTrace, result: resultSentence, reason }) {
   if (!id) throw new Error('id required');
   const text = String(proof || '').trim();
   if (!text) throw new Error('proof required');
@@ -703,6 +729,10 @@ function readyTask(db, { id, actor, proof, lesson, nextTask, landing = {}, resul
   metadata.latest_agent_proof = text;
   metadata.latest_agent_lesson = String(lesson || '').trim() || null;
   metadata.latest_agent_next_task = String(nextTask || '').trim() || null;
+  const resultText = cleanLandingText(resultSentence);
+  if (resultText) metadata.result = resultText;
+  const reasonText = cleanLandingText(reason);
+  if (reasonText) metadata.result_reason = reasonText;
   const landingInput = landing && typeof landing === 'object' ? landing : {};
   for (const key of ['happened', 'checked', 'tested', 'decision']) {
     const cleaned = cleanLandingText(landingInput[key]);
@@ -735,6 +765,7 @@ function readyTask(db, { id, actor, proof, lesson, nextTask, landing = {}, resul
     review_pass_count: reviewPassCount,
     agent_certified: metadata.agent_certified === true,
     agent_certification_policy: metadata.agent_certification_policy || null,
+    result: metadata.result || null,
   };
   if (resultTrace && typeof resultTrace === 'object') {
     payload.result_trace = resultTrace;
@@ -756,13 +787,46 @@ function readyTask(db, { id, actor, proof, lesson, nextTask, landing = {}, resul
   return { ready: true, event, row: updated };
 }
 
-function reviseTask(db, { id, actor, note }) {
+function setTaskResult(db, { id, actor, result }) {
+  if (!id) throw new Error('id required');
+  const text = cleanLandingText(result);
+  if (!text) throw new Error('result required');
+  const row = getTask(db, id);
+  if (!row) return { saved: false, reason: 'not_found' };
+  const now = Date.now();
+  const metadata = row.metadata && typeof row.metadata === 'object' ? { ...row.metadata } : {};
+  metadata.result = text;
+  metadata.result_at = new Date(now).toISOString();
+  metadata.result_by = actor || process.env.ATRIS_AGENT_ID || process.env.USER || null;
+  const updated = withBusyRetry(() => db.prepare(`
+    UPDATE tasks
+       SET metadata = ?,
+           updated_at = ?
+     WHERE id = ?
+  `).run(JSON.stringify(metadata), now, id));
+  if (updated.changes !== 1) return { saved: false, reason: 'stale_task_state' };
+  const latest = getTask(db, id);
+  const event = appendTaskEvent(db, {
+    taskId: id,
+    workspaceRoot: latest.workspace_root,
+    actor: metadata.result_by,
+    eventType: 'result_set',
+    payload: { result: text },
+  });
+  return { saved: true, event, row: latest };
+}
+
+function reviseTask(db, { id, actor, note, allowDone = false }) {
   if (!id) throw new Error('id required');
   const text = String(note || '').trim();
   if (!text) throw new Error('note required');
   const row = getTask(db, id);
   if (!row) return { revised: false, reason: 'not_found' };
-  if (row.status !== 'review') {
+  const acceptedDone = allowDone
+    && row.status === 'done'
+    && row.metadata
+    && row.metadata.approval_status === 'accepted';
+  if (row.status !== 'review' && !acceptedDone) {
     return { revised: false, reason: `not_reviewable_${row.status}` };
   }
   const now = Date.now();
@@ -787,7 +851,19 @@ function reviseTask(db, { id, actor, note }) {
   metadata.human_revision_at = new Date(now).toISOString();
   metadata.human_revision_by = actor || process.env.ATRIS_AGENT_ID || process.env.USER || null;
   metadata.human_revision_note = text;
+  if (acceptedDone) {
+    for (const key of [
+      'accepted_at',
+      'accepted_by',
+      'auto_accepted_at',
+      'auto_accepted_by',
+      'auto_accept_policy',
+    ]) {
+      delete metadata[key];
+    }
+  }
   const revisedStatus = row.claimed_by ? 'claimed' : 'open';
+  const expectedStatus = acceptedDone ? 'done' : 'review';
   const result = withBusyRetry(() => db.prepare(`
     UPDATE tasks
        SET status = ?,
@@ -795,8 +871,8 @@ function reviseTask(db, { id, actor, note }) {
            updated_at = ?,
            metadata = ?
      WHERE id = ?
-       AND status = 'review'
-  `).run(revisedStatus, now, JSON.stringify(metadata), id));
+       AND status = ?
+  `).run(revisedStatus, now, JSON.stringify(metadata), id, expectedStatus));
   if (result.changes !== 1) return { revised: false, reason: 'not_updated' };
   const updated = getTask(db, id);
   const event = appendTaskEvent(db, {
@@ -808,6 +884,7 @@ function reviseTask(db, { id, actor, note }) {
       note: text,
       approval_status: 'revise',
       revision_count: revisionCount,
+      ...(acceptedDone ? { previous_status: row.status } : {}),
     },
   });
   const episode = taskEpisodeFromRevision(updated, event, event.payload);
@@ -1846,6 +1923,7 @@ function taskProjection(db, {
         id: row.id,
         ...(refById.get(row.id) || {}),
         title: row.title,
+        result: row.metadata && row.metadata.result || null,
         status: row.status,
         tag: row.tag,
         workspace_root: row.workspace_root,
@@ -1975,6 +2053,7 @@ module.exports = {
   relabelArchivedTasks,
   isJune10BacklogResetMarker,
   readyTask,
+  setTaskResult,
   reviseTask,
   stageTask,
   noteTask,

package/lib/task-proof.js

@@ -7,6 +7,11 @@ const FILE_PROOF_RE = /(?:^|[\s'"`])(?:\.{0,2}\/|~\/|\/Users\/|src\/|scripts\/|a
 const PATH_ONLY_PROOF_RE = /(?:^|[\s'"`])(?:\.{0,2}\/|~\/|\/Users\/|\/private\/|\/var\/|atris\/runs\/|\.atris\/state\/)[^\s'"`,;)]+(?:[.](?:json|jsonl|md|log|txt|png|jpg|jpeg|pdf))?/i;
 const RECEIPT_OR_ARTIFACT_RE = /\b(?:receipt|artifact|screenshot|log|trace|path=|file=|bytes=|model=|opened=|https?:\/\/)\b/i;
 const RESULT_PAIR_RE = /\b(?:typecheck|build|smoke|test|pytest|verifier|validation|validated|verified|render|diff|sync|lineage|projection)\b.{0,80}\b(?:pass|passed|failed|green|ok|exit\s*0|reviewed)\b|\b(?:pass|passed|failed|green|ok|exit\s*0|reviewed)\b.{0,80}\b(?:typecheck|build|smoke|test|pytest|verifier|validation|validated|verified|render|diff|sync|lineage|projection)\b/i;
+const SUITE_GREEN_CLAIM_RE = /\b(?:tests|test\s+suite|suite)\s+(?:is|are|was|were)?\s*(?:all\s+)?(?:green|pass(?:es|ed)?|ok)\b|\b(?:all|full|whole|entire)\s+(?:tests?|test\s+suite|suite)\s+(?:is|are|was|were)?\s*(?:green|pass(?:es|ed)?|ok)\b|\ball\s+green\b|\b(?:npm|pnpm|yarn)\s+(?:run\s+)?test\b\x60?(?:\s+(?:\d+\s*\/\s*\d+|all|suite))?\s+(?:is\s+)?(?:green|pass(?:es|ed)?|ok)\b/i;
+const CI_RUN_CITATION_RE = /https?:\/\/github[.]com\/[^/\s]+\/[^/\s]+\/actions\/runs\/\d+\b|\brun_id\s*=\s*\d+\b|\brun(?:\s+id)?\s*(?:=|:)?\s*\d+\b/i;
+const COMMIT_PINNED_LOCAL_VERIFY_RE = /\bcommit\s+[0-9a-f]{7,40}\b/i;
+const EXIT_ZERO_RE = /\bexit(?:ed)?(?:\s+code)?\s*0\b/i;
+const SUITE_GREEN_CITATION_REASON = 'cite the CI run URL, run id, or commit-pinned verify command with exit 0 before claiming the suite is green';
 const HUMAN_PROOF_RE = /\b(?:team human approved|human approved|human approval|approved by|accepted by|reviewed by|customer replied|customer approved|customer accepted|replied)\b/i;
 const FILE_ACTION_RE = /\b(?:changed|updated|edited|created|deleted|saved|wrote|patched|reviewed|verified|validated|opened|read)\b/i;
 const VERIFIED_PROOF_RE = /^\[verified\]\s+`[^`]+`\s+passed\s+\(exit 0\)(?:\s|$)/i;
@@ -16,12 +21,29 @@ function compactWhitespace(text) {
   return String(text || '').replace(/\s+/g, ' ').trim();
 }
 
+function hasSuiteGreenCitation(text) {
+  return CI_RUN_CITATION_RE.test(text)
+    || (COMMIT_PINNED_LOCAL_VERIFY_RE.test(text)
+      && COMMAND_PROOF_RE.test(text)
+      && EXIT_ZERO_RE.test(text));
+}
+
 function taskProofState(proof) {
   const text = compactWhitespace(proof);
   if (!text) return { ok: false, reason: 'proof required' };
   if (GENERIC_COMPLETION_PROOF_RE.test(text)) {
     return { ok: false, reason: 'proof must name what was verified, changed, approved, or produced' };
   }
+  if (SUITE_GREEN_CLAIM_RE.test(text)) {
+    if (!hasSuiteGreenCitation(text)) {
+      return {
+        ok: false,
+        code: 'suite_green_citation_required',
+        reason: SUITE_GREEN_CITATION_REASON,
+      };
+    }
+    return { ok: true, reason: 'proof cites a CI run or commit-pinned local verify' };
+  }
   if (COMMAND_PROOF_RE.test(text)) return { ok: true, reason: 'proof names a command' };
   if (HUMAN_PROOF_RE.test(text)) return { ok: true, reason: 'proof names human/customer approval' };
   if (RESULT_PAIR_RE.test(text)) return { ok: true, reason: 'proof names a verifier result' };
@@ -66,7 +88,7 @@ function tailText(text, max = 400) {
 // happily pattern-matches even if nothing ran) and a VERIFIED proof: the command
 // actually executed and exited 0. On failure it returns ok:false so the caller
 // can refuse to mark the task ready. The returned proof string is prefixed
-// `[verified]` and names the command + exit, so it also passes taskProofState.
+// It names the command and exit; suite-green claims still need a citation.
 function buildVerifiedProof(verifyCmd, baseProof = '', runner, options = {}) {
   const cmd = String(verifyCmd || '').trim();
   if (!cmd) return { ok: false, reason: 'verify_command_required' };

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 };