atris 3.63.0 → 3.65.0

package/commands/member.js

@@ -5443,7 +5443,12 @@ function isWikiMinerNoiseName(value) {
   const name = compactSentence(value || '', 120);
   if (!name) return true;
   if (/^[A-Z]{2,}$/.test(name)) return false;
-  return /^(?:i|me|my|mine|myself|we|us|our|ours|ourselves|you|your|yours|yourself|yourselves|he|him|his|himself|she|her|hers|herself|it|its|itself|they|them|their|theirs|themselves|this|that|these|those|the|wiki|mission)$/i.test(name);
+  return /^(?:i|me|my|mine|myself|we|us|our|ours|ourselves|you|your|yours|yourself|yourselves|he|him|his|himself|she|her|hers|herself|it|its|itself|they|them|their|theirs|themselves|this|that|these|those|here|there|where|when|what|who|whom|which|why|how|everything|nothing|something|anything|everyone|anyone|someone|nobody|everybody|anybody|somebody|none|the|wiki|mission)$/i.test(name);
+}
+
+function isWikiMinerSelfLoop(relationship) {
+  const from = lowerCompact(relationship?.from);
+  return from !== '' && from === lowerCompact(relationship?.to);
 }
 
 function normalizeWikiMinerExtraction(raw) {
@@ -5462,7 +5467,7 @@ function normalizeWikiMinerExtraction(raw) {
       to: compactSentence(relationship?.to || '', 120),
       type: allowedRelationTypes.has(String(relationship?.type || '').toLowerCase()) ? String(relationship.type).toLowerCase() : 'uses',
     }))
-    .filter((relationship) => !isWikiMinerNoiseName(relationship.from) && !isWikiMinerNoiseName(relationship.to));
+    .filter((relationship) => !isWikiMinerNoiseName(relationship.from) && !isWikiMinerNoiseName(relationship.to) && !isWikiMinerSelfLoop(relationship));
   return { entities, relationships };
 }
 
@@ -5484,7 +5489,9 @@ function heuristicWikiMinerExtraction(pagePath, pageContent) {
   }
   const entities = [{ type: 'concept', name: title }];
   for (const name of [...candidates].slice(0, 12)) entities.push({ type: /agent|api|sdk|cli|hub|system/i.test(name) ? 'system' : 'concept', name });
-  const relationships = [...candidates].slice(0, 12).map((name) => ({ from: title, to: name, type: 'uses' }));
+  const relationships = [...candidates].slice(0, 12)
+    .map((name) => ({ from: title, to: name, type: 'uses' }))
+    .filter((relationship) => !isWikiMinerSelfLoop(relationship));
   return { entities, relationships };
 }
 
@@ -5538,11 +5545,12 @@ function mergeWikiGraph(graph, extraction, sourcePath) {
 
   const relationshipMap = new Map();
   for (const relationship of graph.relationships || []) {
-    if (isWikiMinerNoiseName(relationship.from) || isWikiMinerNoiseName(relationship.to)) continue;
+    if (isWikiMinerNoiseName(relationship.from) || isWikiMinerNoiseName(relationship.to) || isWikiMinerSelfLoop(relationship)) continue;
     const key = `${lowerCompact(relationship.from)}|${String(relationship.type || 'uses').toLowerCase()}|${lowerCompact(relationship.to)}`;
     relationshipMap.set(key, { ...relationship, sources: Array.isArray(relationship.sources) ? relationship.sources : [] });
   }
   for (const relationship of extraction.relationships || []) {
+    if (isWikiMinerNoiseName(relationship.from) || isWikiMinerNoiseName(relationship.to) || isWikiMinerSelfLoop(relationship)) continue;
     const key = `${lowerCompact(relationship.from)}|${relationship.type}|${lowerCompact(relationship.to)}`;
     const existing = relationshipMap.get(key) || { from: relationship.from, to: relationship.to, type: relationship.type, sources: [] };
     if (sourcePath && !existing.sources.includes(sourcePath)) existing.sources.push(sourcePath);
@@ -5819,7 +5827,6 @@ async function callSupervisorLlm(receipts, logs) {
     const output = { isTTY: false, write() { return true; } };
     const result = await postTurn(supervisorPrompt(receipts, logs), {
       mode: process.env.ATRIS_SUPERVISOR_LLM_MODE || 'fast',
-      route: 'local',
       cwd: process.cwd(),
       output,
       color: false,
@@ -5905,11 +5912,21 @@ async function runSupervisorWake(name, paths, { execute = false } = {}) {
       analysis = normalizeSupervisorAnalysis(llm.analysis, { status: 'ok', llm_source: llm.source });
       if (!analysis) {
         reason = 'llm_json_parse_failed';
-        analysis = emptySupervisorRecommendations({ status: 'parse_error', llm_source: llm.source, llm_error: 'invalid_analysis_shape' });
+        analysis = {
+          ...fallbackSupervisorAnalysis(receipts),
+          status: 'parse_error',
+          llm_source: llm.source,
+          llm_error: 'invalid_analysis_shape',
+        };
       }
     } else if (llm?.error) {
       reason = llm.error === 'invalid_json' ? 'llm_json_parse_failed' : 'llm_analysis_failed';
-      analysis = emptySupervisorRecommendations({ status: llm.error === 'invalid_json' ? 'parse_error' : 'llm_error', llm_source: llm.source, llm_error: llm.error });
+      analysis = {
+        ...fallbackSupervisorAnalysis(receipts),
+        status: llm.error === 'invalid_json' ? 'parse_error' : 'llm_error',
+        llm_source: llm.source,
+        llm_error: llm.error,
+      };
     } else {
       reason = 'llm_not_configured';
       analysis = fallbackSupervisorAnalysis(receipts);
@@ -7351,7 +7368,7 @@ async function runGeneralistWake(name, paths, { execute = false, domainInput = {
     record: domain.ok && proof.status === 'ok',
     libraryBefore: crossDomainLibraryBefore,
     receiptPath,
-    proofPath,
+    proofPath: execute ? proofPath : null,
   });
   proof.learning = {
     library_path: path.relative(root, learning.library_path),
@@ -7782,6 +7799,24 @@ function wakeRuleDirtyMemberScope(ctx) {
   };
 }
 
+// Rule: a goal pinned to a terminal mission must not mint another doomed tick.
+// The goal stays active until a human retires it or revives the mission, so the
+// wake surfaces that decision instead of proposing `member tick --goal` on a
+// dead spine. Unknown mission ids pass through: they may live in a worktree.
+function wakeRuleTerminalMissionGoal(ctx) {
+  const mission = ctx.goalTerminalMission;
+  if (!ctx.goal || !mission) return null;
+  return {
+    decision: 'ask',
+    reason: `goal_mission_terminal:${mission.status}`,
+    needs_user: true,
+    ask: `Goal "${ctx.goal.title}" is pinned to mission ${mission.id} (${mission.status}). Retire the goal or revive the mission, then wake again.`,
+    next_command: `atris member goal-from-mission ${ctx.name}`,
+    goal: ctx.goal,
+    current_experiment: ctx.current || null,
+  };
+}
+
 // Rule: nothing blocks the member, so take the safe next bounded step.
 function wakeRuleSafeBoundedTick(ctx) {
   return {
@@ -7802,6 +7837,7 @@ const WAKE_DECISION_RULES = [
   wakeRuleOpenReviewableProposal,
   wakeRuleScoredNonTickCandidate,
   wakeRuleDirtyMemberScope,
+  wakeRuleTerminalMissionGoal,
   wakeRuleSafeBoundedTick,
 ];
 
@@ -7815,6 +7851,8 @@ function wakeDecision(name, paths, { force = false, runtimeKind = memberRuntimeK
   const steering = readSteeringMemory(paths, name);
   const state = loadMemberGoals(name, paths);
   const goal = activeGoal(state);
+  const pinnedMission = goal?.mission_id ? memberRunMissionMap().get(String(goal.mission_id).trim()) || null : null;
+  const goalTerminalMission = pinnedMission && MISSION_TERMINAL_STATUSES.has(lowerCompact(pinnedMission.status || '')) ? pinnedMission : null;
   const current = memberOpenExperiment(state);
   const generalistDecision = wakeRuleGeneralistDomainFile(name, { purpose, steering, state, goal, current });
   if (generalistDecision) return generalistDecision;
@@ -7860,7 +7898,7 @@ function wakeDecision(name, paths, { force = false, runtimeKind = memberRuntimeK
     next_command: wakeScores.selected.next_command,
   } : null;
 
-  const ctx = { name, force, purpose, nowFile, steering, state, goal, current, blocked, evidence, workspace, checks, wakeScores };
+  const ctx = { name, force, purpose, nowFile, steering, state, goal, goalTerminalMission, current, blocked, evidence, workspace, checks, wakeScores };
   for (const rule of WAKE_DECISION_RULES) {
     const verdict = rule(ctx);
     if (verdict) return composeWakeDecision(ctx, verdict);

package/commands/mission.js

@@ -7,6 +7,7 @@ const readline = require('readline');
 const { spawn, spawnSync } = require('child_process');
 const { hasFlag, readFlag, readIntFlag } = require('../lib/arg-parser');
 const { memberProcessPrompt } = require('../lib/member-context');
+const { memberIdentityLine, missionObjectiveLine } = require('../lib/member-identity');
 const {
   compactErrorPayload,
   compactSuccessPayload,
@@ -570,7 +571,7 @@ function applyMissionRunnerProfile(runner) {
 // it only ever takes an explicit pin (the mission's model or the roster
 // line's); '' lets the engine ride its own default.
 // A mission often still carries the claude model it was created with; an
-// engine that runs only its own models (codex) drops it.
+// engine that runs only its own models (codex, grok) drops it.
 const CLAUDE_FAMILY_RUNNER_ENGINES = new Set(['claude', 'fable', 'haiku']);
 
 function resolveMissionTickRunnerModel(mission) {
@@ -8634,7 +8635,7 @@ function buildTickPrompt(mission, tickIndex, maxTicks, frozen, pings = [], cwd =
     `# Mission Tick ${tickIndex}/${maxTicks}`,
     ...pingLines,
     ``,
-    `**Objective:** ${mission.objective}`,
+    missionObjectiveLine(mission.objective),
     `**Owner:** ${mission.owner}`,
     `**Lane:** ${frozen.lane}`,
     `**Cadence:** ${mission.cadence}`,
@@ -8648,7 +8649,7 @@ function buildTickPrompt(mission, tickIndex, maxTicks, frozen, pings = [], cwd =
     ``,
     `## Your task`,
     `Do ONE increment of work toward the stop condition. ONE. No more.`,
-    `- You are the member "${mission.owner}". Read atris/team/${mission.owner}/MEMBER.md (and SOUL.md if present) before acting, work in that identity, inside its scope and stop rules. After your work, append what you did and what you learned to atris/team/${mission.owner}/logs/<today's date>.md.`,
+    `- ${memberIdentityLine(mission.owner)} Read atris/team/${mission.owner}/MEMBER.md (and SOUL.md if present) before acting, work in that identity, inside its scope and stop rules. After your work, append what you did and what you learned to atris/team/${mission.owner}/logs/<today's date>.md.`,
     `- FIRST: inspect current mission/task state before acting. Read the relevant files, run \`atris mission status ${mission.id}\`, \`git status\`, or \`atris task list\` as needed so you know what's already done.`,
     `- Pick the smallest concrete action that moves the mission forward.`,
     `- Before acting, state your single next move in one sentence.`,

package/commands/pack-craft.js

@@ -1,8 +1,8 @@
 'use strict';
 
 const fs = require('fs');
-const os = require('os');
 const path = require('path');
+const { stateHome } = require('../lib/state-home');
 
 function slugify(value, fallback = 'atris-pack') {
   return String(value || fallback)
@@ -69,7 +69,7 @@ function isNonEmptyTarget(targetDir) {
 function defaultAuthor() {
   try {
     const creds = JSON.parse(
-      fs.readFileSync(path.join(os.homedir(), '.atris', 'credentials.json'), 'utf8')
+      fs.readFileSync(path.join(stateHome(), '.atris', 'credentials.json'), 'utf8')
     );
     if (creds && typeof creds.email === 'string' && creds.email.trim()) return creds.email.trim();
   } catch {

package/commands/publish.js

@@ -1,6 +1,6 @@
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
+const { stateHome } = require('../lib/state-home');
 const { loadCredentials } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
 
@@ -104,7 +104,7 @@ async function publishAtris() {
   }
 
   // Save local copy
-  const localDir = path.join(os.homedir(), '.atris', 'templates', name.toLowerCase().replace(/[^a-z0-9-]/g, '-'));
+  const localDir = path.join(stateHome(), '.atris', 'templates', name.toLowerCase().replace(/[^a-z0-9-]/g, '-'));
   fs.mkdirSync(localDir, { recursive: true });
 
   for (const f of files) {

package/commands/radar.js

@@ -3,6 +3,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const { stateHome } = require('../lib/state-home');
 const { execFileSync } = require('child_process');
 const { parseScopeFlag, pathUnderRoot } = require('../lib/cli-scope');
 
@@ -346,7 +347,7 @@ function loadBusinessCollaboration(root, deps, team = {}, scorecardCount = count
   const business = readJsonFile(path.join(root, '.atris', 'business.json'), deps, null);
   const runtime = readJsonFile(path.join(root, '.atris', 'state', 'runtime.json'), deps, null);
   const sync = readJsonFile(path.join(root, '.atris', 'state', '_sync.json'), deps, null);
-  const cache = readJsonFile(path.join(deps.homeDir || os.homedir(), '.atris', 'businesses.json'), deps, {}) || {};
+  const cache = readJsonFile(path.join(deps.homeDir || stateHome(), '.atris', 'businesses.json'), deps, {}) || {};
   const slug = business?.slug || sync?.workspace_slug || null;
   const cacheEntry = slug && cache ? cache[slug] : null;
   const hasAtris = deps.exists(path.join(root, 'atris'));
@@ -804,7 +805,7 @@ function collectRadar(options = {}) {
     readlink: options.readlinkSync || fs.readlinkSync,
     readdir: options.readdirSync || fs.readdirSync,
     platform: options.platform || os.platform(),
-    homeDir: options.homeDir || os.homedir(),
+    homeDir: options.homeDir || stateHome(),
   };
   const nowMs = options.nowMs || Date.now();
   const tasks = loadTasks(root, deps);

package/commands/router.js

@@ -2,8 +2,8 @@
 
 const crypto = require('node:crypto');
 const fs = require('node:fs');
-const os = require('node:os');
 const path = require('node:path');
+const { stateHome } = require('../lib/state-home');
 const { spawnSync } = require('node:child_process');
 const { loadOverrides, pickLane } = require('../lib/ax-auto-lane');
 
@@ -28,7 +28,7 @@ function readFirstNamedFlag(args, names) {
 }
 
 function resolveRouterPaths(args = [], env = process.env) {
-  const home = env.HOME || os.homedir();
+  const home = stateHome(env);
   return {
     picks: path.resolve(readFirstNamedFlag(args, ['--picks', '--picks-path'])
       || env.ATRIS_ROUTER_PICKS_PATH

package/commands/stream.js

@@ -589,12 +589,33 @@ function worktreeTask(root, deps) {
   return worktreeConfig(root, deps).task;
 }
 
+// The branches a side copy starts from. A commit reachable from any of them
+// was inherited, not made in the copy.
+const WORKTREE_BASE_REFS = Object.freeze([
+  'refs/remotes/origin/HEAD',
+  'refs/remotes/origin/main',
+  'refs/remotes/origin/master',
+  'refs/heads/main',
+  'refs/heads/master',
+]);
+
+function worktreeBaseRefs(root, deps) {
+  const result = runGit(root, ['for-each-ref', '--format=%(refname)', ...WORKTREE_BASE_REFS], deps);
+  if (result.status !== 0) return [];
+  return String(result.stdout || '').split(/\r?\n/).map((line) => line.trim()).filter((ref) => WORKTREE_BASE_REFS.includes(ref));
+}
+
+// Only a commit the copy added on top of its base counts. A fresh copy cut
+// from someone else's commit has none, so its owner shows no work. A repo
+// with no main, master, or origin default keeps the newest commit.
 function collectWorktreeActivityEvents(root, deps, events) {
   const roots = collectWorkspaceRoots(root, deps);
   for (const item of roots) {
     const owner = worktreeOwner(item.root, deps);
     if (!owner) continue;
-    const log = runGit(item.root, ['log', '-1', '--format=%cI%x09%an%x09%s'], deps);
+    const bases = worktreeBaseRefs(item.root, deps);
+    const range = bases.length ? ['HEAD', '--not', ...bases] : [];
+    const log = runGit(item.root, ['log', '-1', '--format=%cI%x09%an%x09%s', ...range], deps);
     if (log.status !== 0 || !String(log.stdout || '').trim()) continue;
     const [ts, author, subject] = String(log.stdout || '').trim().split('\t');
     pushEvent(events, {

package/commands/task.js

@@ -253,6 +253,8 @@ atris task - durable local task state (SQLite, gitignored)
                                            Sweep off-roadmap/duplicate work as archived (not failed);
                                            --from-failed opts in to relabel a fail-closed row (never done)
   atris task clear-done [--before <days>] [--dry-run] [--json]  Archive completed rows, oldest first
+  atris task prune-test-junk [--yes] [--vacuum] [--json]
+                                           Count rows test runs left from temp folders; --yes backs up the db, then removes them
   atris task keep [--json]                 Put away finished and untouched work, then refresh the list
   atris task reap-mission-blockers [--json] Close blocker rows whose missions are complete or stopped
   atris task relabel-archived [--dry-run|--apply]
@@ -1421,7 +1423,7 @@ function taskReviewSummary(task) {
   const reviewPassCount = Number(metadata.agent_review_pass_count || payload.review_pass_count || 0);
   const agentCertified = metadata.agent_certified === true
     || payload.agent_certified === true
-    || reviewPassCount >= AGENT_CERTIFICATION_REVIEW_PASSES;
+    || (reviewPassCount >= AGENT_CERTIFICATION_REVIEW_PASSES && reviewIntegrity.hasIndependentReview(task));
   const reviewedEventHas = (key) => reviewed && reviewed.event_type === 'reviewed'
     && Object.prototype.hasOwnProperty.call(payload, key);
   const clearedReviewFields = new Set(Array.isArray(payload.cleared_review_fields) ? payload.cleared_review_fields : []);
@@ -8841,7 +8843,7 @@ function taskAllowsReviewChat(task, { allowCertified = false } = {}) {
   if (allowCertified) return true;
   if (review.agent_certified === true || metadata.agent_certified === true) return false;
   const reviewPassCount = Number(review.agent_review_pass_count || metadata.agent_review_pass_count || 0);
-  if (reviewPassCount >= AGENT_CERTIFICATION_REVIEW_PASSES) return false;
+  if (reviewPassCount >= AGENT_CERTIFICATION_REVIEW_PASSES && reviewIntegrity.hasIndependentReview(task)) return false;
   const handoff = reviewHandoffForTask(task, { suppressExistingFollowUp: true });
   return !(handoff && (handoff.next_action === 'continue_work' || handoff.next_action === 'human_accept_waiting'));
 }
@@ -9814,6 +9816,78 @@ function cmdClearDone(args) {
   console.log(`cleared ${candidates.length} completed task(s).`);
 }
 
+function formatBytes(bytes) {
+  const mb = Number(bytes || 0) / (1024 * 1024);
+  return mb >= 1 ? `${mb.toFixed(1)} MB` : `${Math.round(Number(bytes || 0) / 1024)} KB`;
+}
+
+// Test runs that forgot ATRIS_TASKS_DB left rows in the shared database
+// under temp folders. Default is a read-only count; --yes backs up, then
+// removes those rows and their history. Real project rows are never touched.
+function cmdPruneTestJunk(args) {
+  const taskDb = getTaskDb();
+  const prune = require('../lib/task-prune');
+  const dbPath = taskDb.getDbPath();
+  const apply = hasFlag(args, '--yes') && !hasFlag(args, '--dry-run');
+  const vacuum = apply && hasFlag(args, '--vacuum');
+  if (!apply) {
+    const plan = prune.dryRun(dbPath);
+    const { rows, ...summary } = plan;
+    if (wantsJson(args)) {
+      printJson({ ok: true, action: 'prune-test-junk', dry_run: true, ...summary });
+      return;
+    }
+    if (plan.missing) {
+      console.log(`no task database at ${dbPath}. nothing to prune.`);
+      return;
+    }
+    const r = plan.remove;
+    console.log('prune-test-junk dry run: nothing was changed.');
+    console.log(`database: ${dbPath} (${formatBytes(plan.db_bytes)}, ${plan.total_tasks} tasks)`);
+    console.log(`would remove ${r.tasks} test task(s) from temp folders, ${r.history_rows} history row(s), `
+      + `${r.stray_history_rows} stray history row(s), ${r.part_uses} part use row(s).`);
+    for (const g of plan.groups) {
+      console.log(`  ${g.prefix.padEnd(22)} ${String(g.tasks).padStart(7)} tasks  ${String(g.history_rows + g.stray_history_rows).padStart(8)} history rows`);
+    }
+    const k = plan.kept;
+    console.log(`kept: ${k.folder_exists} temp task(s) whose folder still exists, ${k.recent} active in the last ${plan.grace_hours} hour(s), `
+      + `${k.held} with history from a real project, ${k.stray_held + k.stray_recent} leftover history set(s) that are recent or name a real project.`);
+    if (r.tasks || r.stray_history_rows) {
+      console.log('run with --yes to remove them. a backup copy is written next to the database first.');
+    }
+    return;
+  }
+
+  if (vacuum && !wantsJson(args)) {
+    console.log('note: --vacuum rewrites the whole file and needs every other atris process idle; it waits a few seconds, then gives up.');
+  }
+  let result;
+  try {
+    result = prune.applyPrune(dbPath, { vacuum });
+  } catch (err) {
+    failTask('atris task prune-test-junk', 'prune_failed', `prune-test-junk stopped: ${err && err.message || err}`, 1);
+  }
+  if (wantsJson(args)) {
+    printJson({ ok: true, action: 'prune-test-junk', dry_run: false, ...result });
+    return;
+  }
+  if (result.missing) {
+    console.log(`no task database at ${dbPath}. nothing to prune.`);
+    return;
+  }
+  const r = result.removed;
+  console.log(`backup: ${result.backup_path} (${result.backup_tasks} tasks)`);
+  console.log(`removed ${r.tasks} test task(s), ${r.history_rows} history row(s), `
+    + `${r.stray_history_rows} stray history row(s), ${r.part_uses} part use row(s).`);
+  const sk = result.skipped;
+  if (sk.held || sk.changed_since_backup || sk.recent || sk.folder_exists) {
+    console.log(`left ${sk.changed_since_backup} that changed after the backup, ${sk.recent} that became active, `
+      + `${sk.folder_exists} whose folder came back, and ${sk.held} with real-project history.`);
+  }
+  console.log(`database now has ${result.total_tasks} tasks, ${formatBytes(result.bytes_after)} on disk`
+    + (result.vacuumed ? ' after vacuum.' : '. run again with --yes --vacuum to shrink the file.'));
+}
+
 function cmdReapMissionBlockers(args) {
   const taskDb = getTaskDb();
   const db = taskDb.open();
@@ -10468,6 +10542,13 @@ function stampReadyVerifyMetadata(taskDb, db, taskId, verify) {
   if (!row) return;
   const metadata = row.metadata && typeof row.metadata === 'object' ? { ...row.metadata } : {};
   metadata.verify = verify;
+  // A real verify stamped at ready means the creation-time degraded flag is
+  // stale: clear it so `task show` stops warning about a missing check. A
+  // diff-only verify keeps the flag; it still cannot fail on real breakage.
+  if (verify.toLowerCase() !== 'git diff --check') {
+    delete metadata.verification_status;
+    delete metadata.verification_degraded_reason;
+  }
   db.prepare(`
     UPDATE tasks
        SET metadata = ?,
@@ -13374,6 +13455,7 @@ async function runTaskCommand(args) {
     case 'fail':   return cmdDone([...rest, '--failed']);
     case 'archive': return cmdArchive(rest);
     case 'clear-done': return cmdClearDone(rest);
+    case 'prune-test-junk': return cmdPruneTestJunk(rest);
     case 'keep': return cmdKeep(rest);
     case 'reap-mission-blockers':
     case 'reap-blockers':