atris 3.16.1 → 3.17.0

package/commands/member.js

@@ -1994,6 +1994,28 @@ function repoRelative(root, filePath) {
   return path.relative(root, filePath).replace(/\\/g, '/');
 }
 
+function dateFromLogPath(relativePath) {
+  const match = String(relativePath || '').match(/\b(\d{4}-\d{2}-\d{2})\b/);
+  return match ? match[1] : null;
+}
+
+function compareLogEvidenceRecentFirst(a, b) {
+  const dateA = a?.date || '';
+  const dateB = b?.date || '';
+  if (dateA !== dateB) return dateB.localeCompare(dateA);
+  const pathCompare = String(a?.path || '').localeCompare(String(b?.path || ''));
+  if (pathCompare !== 0) return pathCompare;
+  return Number(a?.line || 0) - Number(b?.line || 0);
+}
+
+function compareRepeatedFailureSignals(a, b) {
+  const countCompare = Number(b?.count || 0) - Number(a?.count || 0);
+  if (countCompare !== 0) return countCompare;
+  const evidenceCompare = compareLogEvidenceRecentFirst(a?.evidence?.[0], b?.evidence?.[0]);
+  if (evidenceCompare !== 0) return evidenceCompare;
+  return String(a?.pattern || '').localeCompare(String(b?.pattern || ''));
+}
+
 function listFilesBounded(rootDir, { maxFiles = 220, extensions = ['.md', '.txt', '.json', '.jsonl'] } = {}) {
   const files = [];
   const stack = [rootDir];
@@ -2034,12 +2056,13 @@ function stripAutoImproverTitleNoise(text) {
   return compactSentence(clean, 180);
 }
 
-function isAutoImproverGeneratedLogLine(line) {
+function isAutoImproverGeneratedLogLine(line, relativePath = '') {
   const text = String(line || '').trim();
   if (!text) return false;
+  if (String(relativePath || '').startsWith('atris/team/auto-improver/logs/') && /^-\s*summary:\s*/i.test(text)) return true;
   if (/\bauto[- ]improver\b/i.test(text) && /\b(dogfood|receipt|prevented|pain_)\b/i.test(text)) return true;
   if (/\bauto_improver\b/i.test(text)) return true;
-  if (/^-\s*candidate:\s*recurring log pattern:/i.test(text)) return true;
+  if (/^-\s*candidate:\s*/i.test(text)) return true;
   if (/recurring log pattern:\s*(candidate:|recurring log pattern:)/i.test(text)) return true;
   return false;
 }
@@ -2062,12 +2085,15 @@ function collectAutoImproverLogSignals(root) {
   const failureRegex = /\b(error|failed|failure|blocked|timeout|regression|crash|missing proof|naraka|suffering)\b/i;
   const unclearRegex = /\b(tbd|unclear|unknown|needs user|needs owner|needs proof|no next|blocked)\b/i;
   const counts = new Map();
+  const unclearActions = [];
   let filesScanned = 0;
   let linesScanned = 0;
   let unclearNextActions = 0;
   for (const scanRoot of roots) {
     for (const filePath of listFilesBounded(scanRoot)) {
       const relative = repoRelative(root, filePath);
+      const logDate = dateFromLogPath(relative);
+      if (relative.startsWith('atris/logs/archive/')) continue;
       const isRuntimeLog = relative.startsWith('atris/logs/')
         || /^atris\/team\/[^/]+\/logs\//.test(relative)
         || /^atris\/team\/[^/]+\/goals\.(md|json)$/.test(relative)
@@ -2076,37 +2102,52 @@ function collectAutoImproverLogSignals(root) {
       const text = safeReadText(filePath);
       if (!text) continue;
       filesScanned += 1;
-      const lines = text.split(/\r?\n/).slice(-500);
+      const allLines = text.split(/\r?\n/);
+      const lineOffset = Math.max(0, allLines.length - 500);
+      const lines = allLines.slice(-500);
       linesScanned += lines.length;
       for (let index = 0; index < lines.length; index += 1) {
+        const sourceLine = lineOffset + index + 1;
         const line = lines[index];
-        if (isAutoImproverGeneratedLogLine(line)) continue;
+        if (isAutoImproverGeneratedLogLine(line, relative)) continue;
         // Declared verification receipts ("check: <command> ...") describe what
         // was verified, not what broke. Wiki upkeep sweeps write one per page,
         // so counting them as failures spawns bogus recurring-pattern tasks
         // (CLI-199 came from 13 such lines in atris/wiki/log.md).
         if (/^\s*[-*]?\s*check:\s/i.test(line)) continue;
         if (/\b(errors?|fail(?:ed|ures?)|blocked|timeouts?)\s*:\s*0\b/i.test(line)) continue;
-        if (unclearRegex.test(line)) unclearNextActions += 1;
+        if (/\bblocked\s*(?:->|→|to)\s*ready\b/i.test(line)) continue;
+        if (unclearRegex.test(line)) {
+          unclearNextActions += 1;
+          unclearActions.push({
+            path: relative,
+            date: logDate,
+            line: sourceLine,
+            text: compactSentence(line, 180),
+          });
+        }
         if (!failureRegex.test(line)) continue;
         const pattern = normalizeFailurePattern(line);
         if (!pattern) continue;
         const existing = counts.get(pattern) || { pattern, count: 0, evidence: [] };
         existing.count += 1;
-        if (existing.evidence.length < 5) {
-          existing.evidence.push({
-            path: repoRelative(root, filePath),
-            line: index + 1,
-            text: compactSentence(line, 180),
-          });
-        }
+        existing.evidence.push({
+          path: relative,
+          date: logDate,
+          line: sourceLine,
+          text: compactSentence(line, 180),
+        });
         counts.set(pattern, existing);
       }
     }
   }
   const repeated = [...counts.values()]
     .filter((item) => item.count >= 2)
-    .sort((a, b) => b.count - a.count)
+    .map((item) => ({
+      ...item,
+      evidence: item.evidence.sort(compareLogEvidenceRecentFirst).slice(0, 5),
+    }))
+    .sort(compareRepeatedFailureSignals)
     .slice(0, 8);
   return {
     files_scanned: filesScanned,
@@ -2114,9 +2155,19 @@ function collectAutoImproverLogSignals(root) {
     repeated_failures: repeated,
     repeated_failure_count: repeated.length,
     unclear_next_action_count: unclearNextActions,
+    unclear_next_actions: unclearActions.sort(compareLogEvidenceRecentFirst).slice(0, 5),
   };
 }
 
+function autoImproverTaskWaitingForHuman(task, status) {
+  if (status !== 'review') return false;
+  const metadata = task?.metadata || {};
+  const review = task?.review || {};
+  const certified = metadata.agent_certified === true || review.agent_certified === true;
+  const approval = lowerCompact(review.approval_status || metadata.approval_status || task?.approval_status || '');
+  return certified && (!approval || approval === 'pending' || approval === 'agent_certified');
+}
+
 function collectAutoImproverTaskSignals(root) {
   const projectionPath = path.join(root, '.atris', 'state', 'tasks.projection.json');
   const projection = safeReadJson(projectionPath);
@@ -2135,10 +2186,11 @@ function collectAutoImproverTaskSignals(root) {
       status: status || null,
       owner: task.claimed_by || task.assigned_to || task.owner || task.metadata?.assigned_to || null,
     };
+    const waitingForHuman = autoImproverTaskWaitingForHuman(task, status);
     if (status === 'blocked') blockedTasks.push(sample);
     if (status === 'review') reviewTasks.push(sample);
-    if (openStatuses.has(status)) staleTasks.push(sample);
-    if (/\b(tbd|unclear|unknown|needs proof|needs owner|blocked|stale|no next)\b/i.test(`${title} ${task.notes || ''}`)) {
+    if (openStatuses.has(status) && !waitingForHuman) staleTasks.push(sample);
+    if (openStatuses.has(status) && !waitingForHuman && /\b(tbd|unclear|unknown|needs proof|needs owner|blocked|stale|no next)\b/i.test(`${title} ${task.notes || ''}`)) {
       unclearTasks.push(sample);
     }
   }
@@ -2366,7 +2418,9 @@ function collectAutoImproverScan(root = process.cwd()) {
       title: 'Unclear next-action language is accumulating',
       problem: 'Several logs or tasks mention blocked/unclear/proof-needed states without a crisp next move.',
       recommendation: 'Convert the highest-value unclear item into one task with owner, proof, and stop rule.',
-      evidence: taskSignals.unclear_tasks.length ? taskSignals.unclear_tasks : logSignals.repeated_failures.slice(0, 3),
+      evidence: taskSignals.unclear_tasks.length
+        ? taskSignals.unclear_tasks
+        : (logSignals.unclear_next_actions.length ? logSignals.unclear_next_actions : logSignals.repeated_failures.slice(0, 3)),
       score: 18,
     });
   }
@@ -2416,21 +2470,43 @@ function collectAutoImproverScan(root = process.cwd()) {
   };
 }
 
+// Lifecycle filter for wake dedupe: a task that already crossed the review boundary
+// (done/failed/archived, or human-accepted) must never be re-selected as the wake target —
+// that loop produced an endless "existing_task_found OBL-1433" no-op spiral (OBL-1469).
+const AUTO_IMPROVER_INACTIVE_STATUSES = new Set(['done', 'failed', 'archived']);
+
+function autoImproverTaskIsActionable(task) {
+  const status = String(task?.status || '').toLowerCase();
+  if (AUTO_IMPROVER_INACTIVE_STATUSES.has(status)) return false;
+  const approval = String(task?.metadata?.approval_status || task?.approval_status || '').toLowerCase();
+  if (approval === 'accepted') return false;
+  return true;
+}
+
 function findExistingAutoImproverTask(title) {
   const projection = safeReadJson(path.join(process.cwd(), '.atris', 'state', 'tasks.projection.json'));
   const tasks = Array.isArray(projection?.tasks) ? projection.tasks : [];
-  const key = lowerCompact(title);
+  const key = lowerCompact(stripAutoImproverTitleNoise(title));
   if (!key) return null;
   return tasks.find((task) => {
-    const taskTitle = lowerCompact(task.title || '');
+    if (!autoImproverTaskIsActionable(task)) return false;
+    const taskTitle = lowerCompact(stripAutoImproverTitleNoise(task.title || ''));
     if (!taskTitle) return false;
     return taskTitle.includes(key) || key.includes(taskTitle);
   }) || null;
 }
 
-function createAutoImproverTask(candidate, receiptPath) {
+function autoImproverTaskTitle(candidate) {
   const core = stripAutoImproverTitleNoise(candidate?.title || 'Prevent top dogfood failure');
-  const title = `Auto-improver: ${compactSentence(core, 92)}`;
+  return `Auto-improver: ${compactSentence(core, 92)}`;
+}
+
+function existingAutoImproverTaskForCandidate(candidate) {
+  return findExistingAutoImproverTask(autoImproverTaskTitle(candidate));
+}
+
+function createAutoImproverTask(candidate, receiptPath) {
+  const title = autoImproverTaskTitle(candidate);
   const existing = findExistingAutoImproverTask(title);
   if (existing) {
     return {
@@ -2496,11 +2572,18 @@ async function runAutoImproverWake(name, paths, { execute = false, confirmed = f
   const scan = collectAutoImproverScan(process.cwd());
   const mode = execute ? 'execute' : 'dry_run';
   const candidate = scan.prevented_fire_candidate;
-  let createdTask = null;
-  let decision = candidate ? 'scan_found_problem' : 'scan_clean';
-  let reason = candidate ? `top_candidate:${candidate.source}` : 'no_prevented_fire_candidate';
+  const existingTask = candidate ? existingAutoImproverTaskForCandidate(candidate) : null;
+  let createdTask = existingTask ? {
+    ok: true,
+    existing: true,
+    task_ref: taskRef(existingTask),
+    task: existingTask,
+    command: `atris task show ${taskRef(existingTask)} --json`,
+  } : null;
+  let decision = candidate ? (existingTask ? 'existing_task_found' : 'scan_found_problem') : 'scan_clean';
+  let reason = candidate ? (existingTask ? 'auto_improver_task_already_exists' : `top_candidate:${candidate.source}`) : 'no_prevented_fire_candidate';
   let nextCommand = candidate
-    ? `atris member wake ${name} --execute --confirm-autonomy-policy --json`
+    ? (existingTask ? createdTask.command : `atris member wake ${name} --execute --confirm-autonomy-policy --json`)
     : `atris member wake ${name} --json`;
 
   let payload = {
@@ -2571,27 +2654,42 @@ async function runAutoImproverWake(name, paths, { execute = false, confirmed = f
         : 'No bounded prevented-fire task was created yet.',
     },
   };
+  const previousLatest = safeReadJson(path.join(process.cwd(), '.atris', 'state', 'auto-improver-dogfood-latest.json'));
   const finalWrite = writeAutoImproverReceipt(name, payload, plannedReceiptPath);
-  const logPath = appendProjectLog('Auto-improver dogfood scan', {
-    member: name,
-    mode,
-    found: payload.proof.found_problems,
-    prevented: payload.proof.prevented_suffering,
-    pain_before: payload.pain.before,
-    pain_after: payload.pain.after,
-    candidate: candidate ? stripAutoImproverTitleNoise(candidate.title) : '',
-    task: payload.created_task?.task_ref || '',
-    receipt: repoRelative(process.cwd(), finalWrite.receiptPath),
-  });
-  const memberLogPath = appendMemberGoalLog(paths.memberDir, name, 'Auto-improver dogfood scan', {
-    mode,
-    found: payload.proof.found_problems,
-    prevented: payload.proof.prevented_suffering,
-    pain_before: payload.pain.before,
-    pain_after: payload.pain.after,
-    receipt: repoRelative(process.cwd(), finalWrite.receiptPath),
-    next: nextCommand,
-  });
+  // A no-op scan identical to the previous tick earns a receipt but not a journal entry —
+  // the cadence loop was appending the same "found: N, prevented: 0" row every ~4 minutes
+  // and flooding the daily log (2026-06-10 had 100+ identical entries).
+  const createdNewTask = Boolean(payload.created_task) && payload.created_task.existing === false;
+  const duplicateNoop = Boolean(previousLatest)
+    && !createdNewTask
+    && previousLatest.decision === decision
+    && previousLatest.proof?.found_problems === payload.proof.found_problems
+    && previousLatest.pain?.before === payload.pain.before
+    && (previousLatest.created_task?.task_ref || null) === (payload.created_task?.task_ref || null);
+  let logPath = null;
+  let memberLogPath = null;
+  if (!duplicateNoop) {
+    logPath = appendProjectLog('Auto-improver dogfood scan', {
+      member: name,
+      mode,
+      found: payload.proof.found_problems,
+      prevented: payload.proof.prevented_suffering,
+      pain_before: payload.pain.before,
+      pain_after: payload.pain.after,
+      candidate: candidate ? stripAutoImproverTitleNoise(candidate.title) : '',
+      task: payload.created_task?.task_ref || '',
+      receipt: repoRelative(process.cwd(), finalWrite.receiptPath),
+    });
+    memberLogPath = appendMemberGoalLog(paths.memberDir, name, 'Auto-improver dogfood scan', {
+      mode,
+      found: payload.proof.found_problems,
+      prevented: payload.proof.prevented_suffering,
+      pain_before: payload.pain.before,
+      pain_after: payload.pain.after,
+      receipt: repoRelative(process.cwd(), finalWrite.receiptPath),
+      next: nextCommand,
+    });
+  }
 
   return {
     ok: true,
@@ -2610,6 +2708,7 @@ async function runAutoImproverWake(name, paths, { execute = false, confirmed = f
     latest_path: finalWrite.latestPath,
     log_path: logPath,
     member_log_path: memberLogPath,
+    journal_skipped: duplicateNoop ? 'duplicate_noop' : null,
     created_task: payload.created_task,
   };
 }
@@ -2752,14 +2851,17 @@ function appendProjectLog(title, fields = {}) {
 // --- YAML Frontmatter Parser (shared with skill.js) ---
 
 function parseFrontmatter(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  // \r?\n so a CRLF-line-ending MEMBER.md (Windows-edited) still parses; otherwise
+  // the delimiter never matched (and trailing \r broke the per-line key matchers),
+  // silently dropping the member's entire frontmatter — role, skills, permissions, tools.
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!match) return null;
 
   const yaml = match[1];
   const result = {};
   let currentKey = null;
 
-  for (const line of yaml.split('\n')) {
+  for (const line of yaml.split(/\r?\n/)) {
     const listMatch = line.match(/^\s+-\s+(.+)$/);
     if (listMatch && currentKey) {
       if (!Array.isArray(result[currentKey])) result[currentKey] = [];
@@ -3592,12 +3694,23 @@ function memberGoalFromMission(name, ...args) {
   goal.mission_id = runtime.id || goal.mission_id || null;
   goal.mission_north_star = purpose.northStar;
   goal.history = Array.isArray(goal.history) ? goal.history : [];
-  goal.history.push({
+  const historyEntry = {
     at: stampIso(),
     event: existing ? 'goal_from_mission_reused' : 'goal_from_mission_created',
     mission_id: runtime.id || null,
     mission_status: runtime.status || null,
-  });
+  };
+  // Collapse repeated no-op reuse ticks (same mission state) instead of recording an identical entry
+  // every cadence — that grew one member's goals.json to 2,200+ duplicate entries / 13K lines. Real
+  // transitions (created, changed mission id/status) are still kept; only consecutive dupes are dropped.
+  const lastEntry = goal.history[goal.history.length - 1];
+  const isDuplicateReuse = existing && lastEntry
+    && lastEntry.event === historyEntry.event
+    && lastEntry.mission_id === historyEntry.mission_id
+    && lastEntry.mission_status === historyEntry.mission_status;
+  if (!isDuplicateReuse) goal.history.push(historyEntry);
+  // Backstop cap so no event type can grow the file without bound (bloated files self-heal on write).
+  if (goal.history.length > 50) goal.history = goal.history.slice(-50);
   if (!existing) state.goals.push(goal);
   state.goals = [goal, ...state.goals.filter((item) => item !== goal)];
   writeMemberGoals(paths, state);
@@ -7205,6 +7318,94 @@ function memberStatus(name, ...args) {
   );
 }
 
+function memberHistory(name, ...args) {
+  const { spawnSync } = require('child_process');
+
+  const paths = requireMemberDir(name);
+  const asJson = hasFlag(args, '--json');
+  const limitArg = readNumberFlag(args, '--limit', null);
+  const limit = limitArg !== null ? Math.max(1, limitArg) : null;
+
+  // resolve files to track: MEMBER.md + SOUL.md if present
+  const filesToTrack = [];
+  if (fs.existsSync(paths.memberFile)) {
+    filesToTrack.push(paths.memberFile);
+  }
+  const soulPath = path.join(paths.memberDir, 'SOUL.md');
+  if (fs.existsSync(soulPath)) {
+    filesToTrack.push(soulPath);
+  }
+
+  if (filesToTrack.length === 0) {
+    // no files exist yet (unborn member); empty history ok
+    const payload = {
+      ok: true,
+      action: 'history',
+      member: name,
+      files: [],
+    };
+    printJsonOrText(payload, [`identity history: ${name}`, '(no files found)'], asJson);
+    return;
+  }
+
+  // run git log for each file
+  const cwd = process.cwd();
+  const fileHistories = [];
+
+  for (const filePath of filesToTrack) {
+    const relativePath = path.relative(cwd, filePath);
+    const result = spawnSync('git', ['log', '--follow', '--pretty=format:%h|%ai|%s', '--', relativePath], {
+      cwd,
+      encoding: 'utf8',
+    });
+
+    let commits = [];
+    if (result.status === 0 && result.stdout) {
+      const lines = result.stdout.trim().split('\n').filter(Boolean);
+      commits = lines.map((line) => {
+        const [hash, date, subject] = line.split('|');
+        return { hash: hash || '', date: date || '', subject: subject || '' };
+      });
+
+      // apply limit if specified
+      if (limit !== null) {
+        commits = commits.slice(0, limit);
+      }
+    }
+
+    fileHistories.push({
+      path: relativePath,
+      commits,
+    });
+  }
+
+  // render output
+  if (asJson) {
+    const payload = {
+      ok: true,
+      action: 'history',
+      member: name,
+      files: fileHistories,
+    };
+    console.log(JSON.stringify(payload, null, 2));
+  } else {
+    console.log('');
+    console.log(`identity history: ${name}`);
+    console.log('');
+    for (const fileHist of fileHistories) {
+      console.log(`${fileHist.path}:`);
+      if (fileHist.commits.length === 0) {
+        console.log('  (no git history)');
+      } else {
+        for (const commit of fileHist.commits) {
+          console.log(`  ${commit.hash} ${commit.date} ${commit.subject}`);
+        }
+      }
+      console.log('');
+    }
+  }
+}
+
 // --- Command Dispatcher ---
 
 async function memberCommand(subcommand, ...args) {
@@ -7254,6 +7455,8 @@ async function memberCommand(subcommand, ...args) {
       return memberBlock(args[0], args[1], ...args.slice(2));
     case 'status':
       return memberStatus(args[0], ...args.slice(1));
+    case 'history':
+      return memberHistory(args[0], ...args.slice(1));
     case 'supervisor':
       return memberSupervisorCommand(args[0], ...args.slice(1));
     case 'objective-generator':
@@ -7285,6 +7488,7 @@ async function memberCommand(subcommand, ...args) {
       console.log('  review <name> <id>  Accept/discard an experiment with proof');
       console.log('  block <name> <id>   Mark an experiment blocked with a human/orchestrator ask');
       console.log('  status <name>       Show goal, open experiment, value, ask, and recent log');
+      console.log('  history <name>      Show git history of member identity files (MEMBER.md, SOUL.md)');
       console.log('  supervisor recommendations  Show advisory supervisor recommendations');
       console.log('  objective-generator proposals  Show autonomous objective proposal');
       console.log('  generalist proof    Show latest cross-domain generalist proof');