atris 3.80.1 → 3.82.2

package/lib/intents.js

@@ -8,6 +8,13 @@ const INTENTS = Object.freeze([
     plain: 'your agent picks the most useful next step and starts it.',
     offer: 'boot_empty',
   }),
+  Object.freeze({
+    id: 'prioritize_work',
+    say: Object.freeze(['whats the most important work to work on', 'what should we work on next', 'what is the highest priority work', 'help me choose what to work on']),
+    do: 'atris task next --json',
+    plain: 'your agent reads the current goal, existing parts and recent evidence before recommending the next work.',
+    offer: 'always',
+  }),
   Object.freeze({
     id: 'keep_going',
     say: Object.freeze(['keep going while i\'m away', 'run overnight', 'finish this', 'keep working without me']),

package/lib/json-file.js

@@ -34,4 +34,25 @@ function writeJson(filePath, value, { indent = 2 } = {}) {
   return filePath;
 }
 
-module.exports = { readJson, writeJson };
+/**
+ * Write text to a file by way of a temp file in the same folder and a rename, so a
+ * reader never sees half a file and two writers never interleave: the last rename wins
+ * whole. Creates parent dirs. The temp file is removed if the write fails.
+ * @param {string} filePath
+ * @param {string} text
+ * @returns {string} the path written
+ */
+function writeFileAtomic(filePath, text) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tmp = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}.tmp`);
+  try {
+    fs.writeFileSync(tmp, text, 'utf8');
+    fs.renameSync(tmp, filePath);
+  } catch (err) {
+    try { fs.rmSync(tmp, { force: true }); } catch { /* nothing left to clean */ }
+    throw err;
+  }
+  return filePath;
+}
+
+module.exports = { readJson, writeJson, writeFileAtomic };

package/lib/loop-doctor.js

@@ -127,6 +127,20 @@ function walk(value, visit, trail = []) {
   });
 }
 
+function tickSignalIdentity(receipt, value) {
+  if (!value || typeof value !== 'object') return null;
+  const missionId = String((receipt && receipt.mission_id) || value.mission_id || '').trim();
+  const briefId = String((value.claude && value.claude.brief_id) || value.brief_id || '').trim();
+  if (briefId) return `brief:${missionId}:${briefId}`;
+  const hasTickIndex = value.tick_index != null && value.tick_index !== '';
+  const startedAt = typeof value.started_at === 'string' ? value.started_at.trim() : '';
+  const finishedAt = typeof value.finished_at === 'string' ? value.finished_at.trim() : '';
+  if (hasTickIndex && (startedAt || finishedAt)) {
+    return `tick:${missionId}:${value.tick_index}:${startedAt}:${finishedAt}`;
+  }
+  return null;
+}
+
 function receiptFailureSignals(entry) {
   const signals = [];
   walk(entry.receipt, (value, trail) => {
@@ -137,7 +151,7 @@ function receiptFailureSignals(entry) {
     // node carries none.
     const signalTs = objectTimestamp(value) || entry.ts;
     if (typeof value.pause_reason === 'string' && value.pause_reason.trim()) {
-      signals.push({ type: 'pause_reason', value: value.pause_reason.trim(), trail, ts: signalTs });
+      signals.push({ type: 'pause_reason', value: value.pause_reason.trim(), trail, ts: signalTs, signalId: null });
     }
     const status = String(value.status || '').toLowerCase();
     const tickContext = trail.some((part) => part === 'tick' || part === 'ticks');
@@ -148,7 +162,15 @@ function receiptFailureSignals(entry) {
     if (!errored) return;
     const detail = value.error || value.error_message || value.reason || value.message || status;
     const text = typeof detail === 'string' ? detail.trim() : JSON.stringify(detail);
-    if (text) signals.push({ type: 'tick_error', value: text, trail, ts: signalTs });
+    if (text) {
+      signals.push({
+        type: 'tick_error',
+        value: text,
+        trail,
+        ts: signalTs,
+        signalId: tickSignalIdentity(entry.receipt, value),
+      });
+    }
   });
   const unique = new Map();
   for (const signal of signals) unique.set(`${signal.type}\0${signal.value}`, signal);
@@ -157,10 +179,16 @@ function receiptFailureSignals(entry) {
 
 function repeatedFailureFindings(receipts, nowIso, freshnessMs) {
   const groups = new Map();
+  const seenSignalIds = new Map();
   for (const entry of receipts) {
     for (const signal of receiptFailureSignals(entry)) {
       const key = `${signal.type}\0${signal.value}`;
       if (!groups.has(key)) groups.set(key, []);
+      if (signal.signalId) {
+        const dedupKey = `${key}\0${signal.signalId}`;
+        if (seenSignalIds.has(dedupKey)) continue;
+        seenSignalIds.set(dedupKey, true);
+      }
       groups.get(key).push({ ts: signal.ts || entry.ts, receipt: path.basename(entry.file), trail: signal.trail });
     }
   }
@@ -267,10 +295,16 @@ function isOpenMission(mission) {
   return mission && !TERMINAL_MISSION_STATUSES.has(String(mission.status || 'planning').toLowerCase());
 }
 
+function isLoopDoctorRepairMission(mission) {
+  const objective = String(mission && mission.objective || '').trim();
+  return /^\[loop-doctor:[^\]]+\]/i.test(objective);
+}
+
 function isDueCapableMission(mission) {
   const cadence = String(mission && mission.cadence || 'manual').trim().toLowerCase();
   const runner = String(mission && mission.runner || 'manual').trim().toLowerCase();
   return isOpenMission(mission)
+    && !isLoopDoctorRepairMission(mission)
     && cadence !== 'manual'
     && cadence !== ''
     && mission.always_on === true

package/lib/map-refs.js

@@ -194,16 +194,32 @@ function fixMapRefs(root, mapFile = 'atris/MAP.md') {
 }
 
 // The short routing map loads at boot; exact line refs live in the notes file.
-// Both are checked and fixed, so moving a ref out of the boot map never hides it.
+// A workspace may split the notes into one file per area under atris/refs/map/,
+// with MAP-NOTES.md left as their index. Every one is checked and fixed, so
+// moving a ref out of the boot map or into an area note never hides it.
 const MAP_REF_DOCS = ['atris/MAP.md', 'atris/refs/MAP-NOTES.md'];
+const MAP_NOTES_DIR = 'atris/refs/map';
+
+function isFile(file) {
+  try { return fs.statSync(file).isFile(); } catch (error) {
+    if (error.code === 'ENOENT' || error.code === 'ENOTDIR') return false;
+    throw error;
+  }
+}
+
+function areaNoteDocs(root) {
+  let names;
+  try { names = fs.readdirSync(path.resolve(root, MAP_NOTES_DIR)); } catch (error) {
+    if (error.code === 'ENOENT' || error.code === 'ENOTDIR') return [];
+    throw error;
+  }
+  return names.filter(name => name.endsWith('.md')).sort()
+    .map(name => `${MAP_NOTES_DIR}/${name}`)
+    .filter(doc => isFile(path.resolve(root, doc)));
+}
 
 function existingMapDocs(root) {
-  return MAP_REF_DOCS.filter(doc => {
-    try { return fs.statSync(path.resolve(root, doc)).isFile(); } catch (error) {
-      if (error.code === 'ENOENT' || error.code === 'ENOTDIR') return false;
-      throw error;
-    }
-  });
+  return [...MAP_REF_DOCS.filter(doc => isFile(path.resolve(root, doc))), ...areaNoteDocs(root)];
 }
 
 // Boot scores the docs every session, and checking every ref means reading
@@ -284,9 +300,53 @@ function fixMapDocs(root) {
   return { changes, left };
 }
 
+// Lines from the deep map notes that share words with a query, for prompts that
+// cannot open files themselves. With area notes, the index only describes them,
+// so the notes are read instead. Notes are ranked by how many query words they
+// match, and the budget fills from the best note first, its best lines first.
+function mapNotesExcerpt(root, query, maxChars) {
+  const words = [...new Set(String(query || '').toLowerCase().split(/[^a-z0-9]+/).filter(w => w.length >= 4))];
+  if (!words.length || !(maxChars > 0)) return '';
+  // The notes file is read too while it still holds real notes, so a project
+  // that has moved only some of them into area notes keeps the rest.
+  const notes = existingMapDocs(root).filter(doc => doc !== MAP_REF_DOCS[0])
+    .filter(doc => doc !== MAP_REF_DOCS[1] || !areaNoteDocs(root).length || holdsRealNotes(fs.readFileSync(path.resolve(root, doc), 'utf8')));
+  const ranked = notes.map((doc, order) => {
+    const lines = fs.readFileSync(path.resolve(root, doc), 'utf8').split(/\r?\n/)
+      .map((line, index) => ({ line, index, hits: words.filter(w => line.toLowerCase().includes(w)).length }))
+      .filter(row => row.hits > 0)
+      .sort((a, b) => b.hits - a.hits || a.index - b.index);
+    const matched = new Set(words.filter(w => lines.some(row => row.line.toLowerCase().includes(w))));
+    return { doc, order, lines, matched: matched.size, total: lines.reduce((sum, row) => sum + row.hits, 0) };
+  }).filter(note => note.lines.length)
+    .sort((a, b) => b.matched - a.matched || b.total - a.total || a.order - b.order);
+  const out = [];
+  let used = 0;
+  for (const note of ranked) {
+    for (const row of note.lines) {
+      // Lines are joined by one newline, so only lines after the first pay for it.
+      const room = maxChars - used - (out.length ? 1 : 0);
+      if (room <= 0) return out.join('\n');
+      if (row.line.length > room) {
+        out.push(row.line.slice(0, room));
+        return out.join('\n');
+      }
+      out.push(row.line);
+      used += row.line.length + (out.length > 1 ? 1 : 0);
+    }
+  }
+  return out.join('\n');
+}
+
+// An index line links into atris/refs/map/; a real note names code or a search.
+function holdsRealNotes(text) {
+  return text.split(/\r?\n/).some(line => !line.includes('](map/')
+    && (/`[\w./-]+\.(?:js|mjs|cjs|ts|py|sh|json)(?::\d+(?:-\d+)?)?`/.test(line) || /^\s*rg "/.test(line)));
+}
+
 // Repo-relative path of the notes file when this workspace has one, else null.
 function mapNotesPath(root) {
   return existingMapDocs(root).includes(MAP_REF_DOCS[1]) ? MAP_REF_DOCS[1] : null;
 }
 
-module.exports = { MAP_REF_DOCS, existingMapDocs, mapNotesPath, checkMapRefs, checkMapDocs, fixMapRefs, fixMapDocs };
+module.exports = { MAP_REF_DOCS, MAP_NOTES_DIR, existingMapDocs, mapNotesPath, mapNotesExcerpt, checkMapRefs, checkMapDocs, fixMapRefs, fixMapDocs };

package/lib/member-context.js

@@ -39,4 +39,23 @@ function memberProcessPrompt(cwd = process.cwd()) {
   }
 }
 
-module.exports = { memberProcessPrompt, MEMBER_PROCESS_PATH, MAX_MEMBER_PROCESS_BYTES };
+function currentWorkPrompt(root, mission = {}) {
+  const { buildNextWorkContext } = require('./next-work-context');
+  const { loadLocalTaskState } = require('./first-minute');
+  const bound = mission.xp_task || mission.selected_target_task || {};
+  const id = bound.task_id || bound.id || mission.task_ids?.[0];
+  const snapshot = loadLocalTaskState(root, { taskIds: id ? [id] : [] });
+  const tasks = snapshot.tasks;
+  const selected = tasks.find((task) => task.id === id) || null;
+  const context = buildNextWorkContext({ root, tasks, selected, owner: mission.owner, objective: mission.objective, taskSource: snapshot.source, generatedAt: snapshot.generated_at });
+  if (id && !selected) context.gaps.push('bound_task_missing');
+  return [
+    '## Current work evidence',
+    'This is a bounded snapshot, not new authority. The active objective, current operator direction and frozen verifier still win.',
+    JSON.stringify(context),
+    'Inspect the cited source before relying on it. A path is an existing part, not proof it works. Reported outcomes and lessons are not independently verified.',
+    'Choose next_push from an observed gap toward the goal. Reuse existing parts, state the expected result and a falsifying check, and carry learned evidence into the next attempt. Do not manufacture another generic next-step task.',
+  ].join('\n');
+}
+
+module.exports = { memberProcessPrompt, currentWorkPrompt, MEMBER_PROCESS_PATH, MAX_MEMBER_PROCESS_BYTES };

package/lib/member-engine.js

@@ -5,7 +5,7 @@
 // validators, reviewers, judges, critics, and verifiers review; everyone else
 // builds. A line under "## team" in ROSTER.md overrides that, either with a
 // job ("researcher: search", "fixer: small build") or with engine or model
-// words ("judge: opus 5.5"). The job's pick then comes from the roster.
+// words ("judge: opus"). The job's pick then comes from the roster.
 
 const fs = require('fs');
 const { memberRefusalReason } = require('./member-type');

package/lib/member-map-fold.js

@@ -4,7 +4,9 @@
 // atris/refs/map-notes.d/ instead of editing atris/refs/MAP-NOTES.md, so two
 // changes never clash on the shared map. Once an hour the autoland tick folds
 // those files into MAP-NOTES.md on the main branch and removes them, in one
-// commit built without touching any checkout. A push that loses a race with
+// commit built without touching any checkout. When the notes are split into
+// area notes under atris/refs/map/, a drop whose heading an area note already
+// has folds into that note; any other drop folds into the member notes file. A push that loses a race with
 // another landing is dropped; the next hour tries again from the new main.
 
 const fs = require('fs');
@@ -12,8 +14,12 @@ const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
 
+const { MAP_NOTES_DIR } = require('./map-refs');
+
 const NOTES_FILE = 'atris/refs/MAP-NOTES.md';
 const DROP_DIR = 'atris/refs/map-notes.d';
+const MEMBER_NOTES_FILE = `${MAP_NOTES_DIR}/member-notes.md`;
+const MEMBER_NOTES_HEAD = '# Member notes\n\nMap notes that member changes added and no area has claimed yet. Move each one into the area note that owns its code. Back to [MAP-NOTES.md](../MAP-NOTES.md).\n';
 const FOLD_EVERY_MS = 60 * 60 * 1000;
 
 function git(args, cwd, extraEnv = {}) {
@@ -71,6 +77,34 @@ function foldNotesText(notes, drops) {
   return { text: lines.length ? `${lines.join('\n')}\n` : '', added };
 }
 
+// Which notes file each drop folds into. Without area notes every drop goes to
+// MAP-NOTES.md as before.
+function foldTargets(root, baseSha, drops) {
+  const read = (file) => {
+    const blob = git(['cat-file', 'blob', `${baseSha}:${file}`], root);
+    return blob.ok ? blob.stdout : null;
+  };
+  const listed = git(['ls-tree', '--name-only', baseSha, '--', `${MAP_NOTES_DIR}/`], root).stdout
+    .split('\n').filter((f) => f.endsWith('.md')).sort();
+  const targets = new Map();
+  const put = (file, text, drop) => {
+    if (!targets.has(file)) targets.set(file, { text, drops: [] });
+    targets.get(file).drops.push(drop);
+  };
+  if (!listed.length) {
+    for (const drop of drops) put(NOTES_FILE, read(NOTES_FILE) || '', drop);
+    return targets;
+  }
+  const notes = listed.map((file) => ({ file, text: read(file) || '' }));
+  for (const drop of drops) {
+    const first = trimEnd(drop.text).split('\n').find((l) => l.trim()) || '';
+    const owner = isHeading(first) && notes.find((note) => note.text.split('\n').some((l) => l.trim() === first.trim()));
+    if (owner) put(owner.file, owner.text, drop);
+    else put(MEMBER_NOTES_FILE, read(MEMBER_NOTES_FILE) || MEMBER_NOTES_HEAD, drop);
+  }
+  return targets;
+}
+
 function mainBranch(root, remote) {
   const head = git(['symbolic-ref', '--short', `refs/remotes/${remote}/HEAD`], root).stdout.trim();
   return head.startsWith(`${remote}/`) ? head.slice(remote.length + 1) : 'master';
@@ -96,19 +130,23 @@ function foldMapNotesOnMain(root, { base = '', remote = 'origin', push = true }
     if (!blob.ok) return { folded: 0, reason: 'drop_unreadable', detail: file };
     drops.push({ file, text: blob.stdout });
   }
-  const current = git(['cat-file', 'blob', `${baseSha}:${NOTES_FILE}`], root);
-  const { text, added } = foldNotesText(current.ok ? current.stdout : '', drops);
-
+  const targets = foldTargets(root, baseSha, drops);
+  let added = 0;
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'atris-map-fold-'));
   try {
     const index = { GIT_INDEX_FILE: path.join(tmp, 'index') };
-    const notesPath = path.join(tmp, 'notes');
-    fs.writeFileSync(notesPath, text);
-    const blob = git(['hash-object', '-w', notesPath], root).stdout.trim();
-    const built = git(['read-tree', baseSha], root, index).ok
-      && /^[0-9a-f]{40,64}$/.test(blob)
-      && git(['update-index', '--add', '--cacheinfo', `100644,${blob},${NOTES_FILE}`], root, index).ok
-      && git(['update-index', '--force-remove', '--', ...files], root, index).ok;
+    let built = git(['read-tree', baseSha], root, index).ok;
+    for (const [target, { text: currentText, drops: targetDrops }] of targets) {
+      if (!built) break;
+      const folded = foldNotesText(currentText, targetDrops);
+      added += folded.added;
+      const notesPath = path.join(tmp, 'notes');
+      fs.writeFileSync(notesPath, folded.text);
+      const blob = git(['hash-object', '-w', notesPath], root).stdout.trim();
+      built = /^[0-9a-f]{40,64}$/.test(blob)
+        && git(['update-index', '--add', '--cacheinfo', `100644,${blob},${target}`], root, index).ok;
+    }
+    built = built && git(['update-index', '--force-remove', '--', ...files], root, index).ok;
     const tree = built ? git(['write-tree'], root, index).stdout.trim() : '';
     const message = `Fold ${files.length} map ${files.length === 1 ? 'note' : 'notes'} from member changes into the shared map`;
     const commit = tree ? git(['commit-tree', tree, '-p', baseSha, '-m', message], root).stdout.trim() : '';

package/lib/member-map-inbox.js

@@ -13,7 +13,8 @@ const path = require('path');
 const { spawnSync } = require('child_process');
 
 const INBOX_DIR = 'atris/refs/map-inbox';
-const SHARED_MAP = /(?:^|\/)MAP(?:-NOTES)?\.md$/;
+// The area notes that MAP-NOTES.md may index are shared map files too.
+const SHARED_MAP = /(?:^|\/)MAP(?:-NOTES)?\.md$|^atris\/refs\/map\/[^/]+\.md$/;
 
 function run(args, cwd, extraEnv = {}, { raw = false } = {}) {
   const env = { ...process.env, ...extraEnv, GIT_NO_REPLACE_OBJECTS: '1' };

package/lib/mission-core.js

@@ -38,7 +38,7 @@ const {
   shortRecordLabel,
   shortRecordRef,
 } = require('./short-name');
-const { readJson, writeJson } = require('./json-file');
+const { readJson, writeJson, writeFileAtomic } = require('./json-file');
 
 const VALID_STATUSES = new Set(['planning', 'running', 'ready', 'paused', 'blocked', 'stopped', 'complete']);
 const TERMINAL_STATUSES = new Set(['stopped', 'complete']);
@@ -827,10 +827,17 @@ function loadTaskDb(asJson = false) {
   }
 }
 
+// The projection has one writer and one shape: `atris task`'s writeDefaultProjection, which
+// enriches the rows and writes through a temp file and a rename. Writing the bare rows here
+// left readers a different shape depending on which command ran last. The fallback (only if
+// the task command cannot load) still writes atomically.
 function writeMissionTaskProjection(taskDb, db, workspaceRoot) {
+  let writer = null;
+  try { writer = require('../commands/task').writeDefaultProjection; } catch { writer = null; }
+  if (typeof writer === 'function') return writer(taskDb, db, { root: workspaceRoot });
   const projection = taskDb.taskProjection(db, { workspaceRoot, limit: 500 });
   const outPath = path.join(workspaceRoot, '.atris', 'state', 'tasks.projection.json');
-  writeJson(outPath, projection);
+  writeFileAtomic(outPath, JSON.stringify(projection, null, 2) + '\n');
   return { projection, outPath };
 }
 

package/lib/next-work-context.js

@@ -0,0 +1,190 @@
+'use strict';
+
+// A bounded, read-only handoff of facts for the next decision. Ranking and
+// execution stay with the existing picker, member and verification gates.
+const fs = require('fs');
+const path = require('path');
+const { meaningfulWords } = require('./short-name');
+
+function clip(value, max = 360) {
+  const text = typeof value === 'string' ? value.replace(/\s+/g, ' ').trim() : '';
+  return text.length > max ? `${text.slice(0, max - 3)}...` : text;
+}
+
+function localFile(root, name) {
+  try {
+    const base = fs.realpathSync(root);
+    const file = fs.realpathSync(path.resolve(base, name));
+    const rel = path.relative(base, file);
+    if (rel.startsWith(`..${path.sep}`) || rel === '..' || path.isAbsolute(rel)) return null;
+    return fs.statSync(file).isFile() ? file : null;
+  } catch { return null; }
+}
+
+function readSource(root, name, maxBytes) {
+  const file = localFile(root, name);
+  if (!file) return { path: name, text: '', unavailable: true };
+  let fd;
+  try {
+    fd = fs.openSync(file, 'r');
+    const stat = fs.fstatSync(fd);
+    const buffer = Buffer.alloc(Math.min(stat.size, maxBytes));
+    const count = fs.readSync(fd, buffer, 0, buffer.length, 0);
+    return { path: name, text: buffer.subarray(0, count).toString('utf8'), truncated: stat.size > maxBytes, modified_at: stat.mtime.toISOString() };
+  } catch { return { path: name, text: '', unavailable: true }; }
+  finally { if (fd !== undefined) fs.closeSync(fd); }
+}
+
+// Keep the offline projection fallback, but a known row's current database
+// status always wins. Include finished rows so their outcomes are not lost.
+function reconcileTaskRows(rows, projected, lookup = () => null) {
+  const known = new Map(rows.map((row) => [row.id, row]));
+  const seen = new Set();
+  const merged = [];
+  for (const row of projected) {
+    if (!row || typeof row !== 'object') continue;
+    // Older offline snapshots have only a display reference. Preserve that
+    // evidence without pretending it has a database identity or authority.
+    if (!row.id) { merged.push(row); continue; }
+    if (seen.has(row.id)) continue;
+    seen.add(row.id);
+    const current = known.get(row.id) || lookup(row.id);
+    if (current !== false) merged.push(current || row);
+  }
+  return [...merged, ...rows.filter((row) => !seen.has(row.id))];
+}
+
+function matchingParts(root, map, query) {
+  const wanted = new Set(meaningfulWords(query, 100));
+  const found = new Map();
+  map.text.split(/\r?\n/).forEach((line, index) => {
+    if (!line.startsWith('|')) return;
+    const score = meaningfulWords(line, 100).filter((word) => wanted.has(word)).length;
+    if (!score) return;
+    for (const match of line.matchAll(/`([^`]+)`/g)) {
+      const name = match[1].replace(/:\d+$/, '');
+      if (path.isAbsolute(name) || !localFile(root, name) || found.has(name)) continue;
+      found.set(name, { path: name, source: `${map.path}:${index + 1}`, description: clip(line.replace(/`/g, ''), 180), score });
+    }
+  });
+  return [...found.values()].sort((a, b) => b.score - a.score).slice(0, 5)
+    .map(({ score, ...part }) => part);
+}
+
+function recentOutcomes(tasks, selected) {
+  return tasks.filter((task) => ['done', 'failed', 'review'].includes(task.status))
+    .sort((a, b) => Number(b.id === selected?.id) - Number(a.id === selected?.id)
+      || Number(b.updated_at || 0) - Number(a.updated_at || 0))
+    .slice(0, 3).map((task) => {
+      const meta = task.metadata || {};
+      return {
+        task_id: clip(task.id, 120),
+        title: clip(task.title, 160),
+        status: task.status,
+        result: clip(task.result || meta.result),
+        lesson: clip(task.review?.lesson || meta.latest_agent_lesson),
+        next: clip(task.review?.next_task || meta.latest_agent_next_task),
+        proof: clip(task.review?.proof || meta.latest_agent_proof),
+        validation: task.status === 'failed' ? 'failed' : task.status === 'review' ? 'review_pending'
+          : meta.accepted_by && meta.accepted_at ? 'accepted' : 'reported',
+      };
+    });
+}
+
+function otherOwner(task, owner) {
+  const assigned = typeof task.metadata?.assigned_to === 'string' ? task.metadata.assigned_to.trim() : '';
+  return Boolean((task.claimed_by && task.claimed_by !== owner) || (assigned && assigned !== owner));
+}
+
+function candidateEvidence(tasks, selected, goal, owner) {
+  const words = new Set(meaningfulWords(goal?.text, 100));
+  const { heldForPerson } = require('./member-task-pick');
+  return tasks.filter((task) => task.id !== selected?.id && ['open', 'claimed', 'review'].includes(task.status))
+    .map((task) => {
+      const meta = task.metadata || {};
+      const why = clip(meta.why_it_matters || task.explanation?.why_it_matters, 240);
+      const overlap = new Set(meaningfulWords(`${task.title} ${meta.objective || ''} ${why}`, 100).filter((word) => words.has(word))).size;
+      return {
+        task_id: clip(task.id, 120), title: clip(task.title, 160), status: task.status,
+        owner: clip(task.claimed_by || meta.assigned_to, 80) || null,
+        why: why || null,
+        held: heldForPerson(task) || (otherOwner(task, owner) ? 'other_owner' : null),
+        goal_word_overlap: overlap,
+      };
+    }).sort((a, b) => b.goal_word_overlap - a.goal_word_overlap).slice(0, 3);
+}
+
+function buildNextWorkContext({ root, tasks = [], selected = null, owner = '', taskSource = 'projection', objective = '', generatedAt = null }) {
+  const scoreboard = readSource(root, '.atris/state/scoreboard.json', 16384);
+  const map = readSource(root, 'atris/MAP.md', 65536);
+  let goal = null;
+  try {
+    const value = scoreboard.truncated ? null : JSON.parse(scoreboard.text);
+    if (clip(value?.goal)) goal = { text: clip(value.goal, 600), source: scoreboard.path, updated_at: typeof value.updated_at === 'string' ? clip(value.updated_at, 80) : null };
+  } catch { /* Missing or unreadable knowledge stays unknown. */ }
+  const meta = selected?.metadata || {};
+  const rawCheck = typeof (meta.verify || meta.verifier) === 'string' ? (meta.verify || meta.verifier).trim() : '';
+  // Never offer an ellipsis as an executable command.
+  const check = rawCheck.length <= 600 ? rawCheck : '';
+  const { taskCheck, heldForPerson } = require('./member-task-pick');
+  const runnable = check && taskCheck({ metadata: { verify: check } }).runnable;
+  const parts = matchingParts(root, map, [objective, selected?.title, meta.objective, goal?.text].filter(Boolean).join(' '));
+  const gaps = [];
+  if (!goal) gaps.push('current_goal_missing');
+  if (taskSource === 'none') gaps.push('task_state_missing');
+  if (scoreboard.truncated) gaps.push('goal_source_truncated');
+  if (map.unavailable) gaps.push('parts_map_missing');
+  else if (!parts.length) gaps.push('matching_parts_missing');
+  if (map.truncated) gaps.push('parts_map_truncated');
+  if (selected && !runnable) gaps.push('runnable_check_missing');
+  if (rawCheck.length > 600) gaps.push('check_too_large_for_snapshot');
+  if (taskSource === 'projection' || taskSource === 'mixed') gaps.push('task_snapshot_not_authoritative');
+  if (generatedAt && Date.now() - Date.parse(generatedAt) > 3 * 86400000) gaps.push('task_snapshot_stale');
+  const why = clip(meta.why_it_matters || selected?.explanation?.why_it_matters);
+  if (selected && !why) gaps.push('reason_missing');
+  let kind = selected && runnable ? 'execute' : 'discover';
+  if (gaps.includes('task_snapshot_not_authoritative') || gaps.includes('task_snapshot_stale')) kind = 'discover';
+  let reason = selected ? 'Inspect the relevant source and establish the missing evidence before changing it.'
+    : 'No selectable job is recorded. Find one observed gap toward the current goal, with a falsifying check.';
+  if (kind === 'execute') reason = why || 'Run the recorded check against the relevant source before claiming progress.';
+  if (selected && !['open', 'claimed', 'review'].includes(selected.status)) {
+    kind = 'discover'; reason = 'The bound task is no longer active. Inspect its recorded result before proposing another gap.';
+    gaps.push(selected.status === 'done' ? 'bound_task_already_finished' : 'bound_task_not_active');
+  } else if (selected && heldForPerson(selected)) { kind = 'human_decision'; reason = 'This work is held for a person by the existing task policy.'; }
+  else if (selected?.status === 'review') {
+    const certified = selected.review?.agent_certified || meta.agent_certified || Number(meta.agent_review_pass_count) >= 2;
+    kind = certified ? 'human_decision' : selected.claimed_by === owner ? 'wait' : 'review';
+    reason = certified ? 'The recorded work needs human acceptance.' : 'A different actor must check the finished diff before more work is chosen.';
+  } else if (selected && otherOwner(selected, owner)) {
+    kind = 'wait'; reason = 'Another owner holds this job. Do not duplicate their work.';
+  }
+  const context = {
+    schema: 'atris.next_work_context.v1',
+    workspace_root: path.resolve(root),
+    captured_at: new Date().toISOString(),
+    task_source: taskSource,
+    goal,
+    parts,
+    candidates: candidateEvidence(tasks, selected, goal, owner),
+    recent_outcomes: recentOutcomes(tasks, selected),
+    gaps,
+    next_step: { kind, reason, check: check || null },
+    sources: [scoreboard, map].map(({ text, ...source }) => source),
+    selection_basis: 'existing queue policy; candidate keyword overlap is a discovery hint, not measured business value',
+  };
+  // Keep the packet bounded even with long unicode text or unusual paths.
+  while (Buffer.byteLength(JSON.stringify(context)) > 10000) {
+    if (!gaps.includes('context_budget_limited')) gaps.push('context_budget_limited');
+    if (context.parts.length) context.parts.pop();
+    else if (context.candidates.length) context.candidates.pop();
+    else if (context.recent_outcomes.length) context.recent_outcomes.pop();
+    else {
+      context.next_step.check = null;
+      if (context.next_step.kind === 'execute') context.next_step.kind = 'discover';
+      break;
+    }
+  }
+  return context;
+}
+
+module.exports = { buildNextWorkContext, reconcileTaskRows };