atris 3.37.0 → 3.38.0

package/lib/functional-owner.js

@@ -179,11 +179,8 @@ function resolveFunctionalOwner({ requestedOwner, title, tag, note, goal, root,
 }
 
 module.exports = {
-  ENGINE_OWNER_IDS,
   FUNCTIONAL_MEMBER_TOPICS,
   normalizeOwnerSlug,
-  isEngineOwner,
   listWorkspaceMemberSlugs,
-  proposedMemberSlugFromTask,
   resolveFunctionalOwner,
 };

package/lib/inspect-fields.js

@@ -168,7 +168,6 @@ module.exports = {
   missionAckInspectValue,
   missionPingsInspectValue,
   missionInspectFieldValues,
-  formatInspectFieldText,
   inspectTextLines,
   buildInspectPayload,
 };

package/lib/known-commands.js

@@ -2,8 +2,8 @@
 
 const knownCommands = ['init', 'log', 'logs', 'wish', 'drill', 'dream', 'now', 'goal', 'wtf', 'orb', 'radar', 'stream', 'ctop', 'launchpad', 'status', 'analytics', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', '_start', 'plan', 'do', 'review', 'release',
                        'activate', '_activate', 'agent', 'team', 'chat', 'fast', 'ax', 'console', 'serve', 'login', 'logout', 'whoami', 'switch', 'use', 'accounts', '_resolve', '_profile-email', '_switch-session', 'shell-init', 'update', 'upgrade', 'version', 'help', 'next', 'atris',
-                       'clean', 'close', 'harvest', 'verify', 'search', 'scout', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'plugin', 'experiments', 'bench', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'watch', 'cloud', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube',
-                       'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'agents', 'probe', 'worktree', 'land', 'autoland', 'drive', 'aeo', 'slop', 'strings', 'write', 'security-review', 'secure', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail',
+                       'clean', 'close', 'harvest', 'verify', 'recover', 'search', 'scout', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'teach', 'plugin', 'experiments', 'bench', 'router', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'watch', 'cloud', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube',
+                       'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'agents', 'probe', 'worktree', 'land', 'autoland', 'drive', 'aeo', 'slop', 'strings', 'write', 'security-review', 'secure', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'sync-checkout',
                        'github', 'vercel', 'supabase', 'linear', 'stripe', 'gmail', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
                        'fork', 'browse', 'publish', 'pack', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'fleet-report', 'loops', 'self-improve', 'compile', 'spaceship', 'truth', 'sign', 'engine', 'engines', 'feed', 'brief'];
 

package/lib/learnings.js

@@ -222,8 +222,6 @@ function exportMarkdown() {
 module.exports = {
   TYPES,
   SOURCES,
-  getLearningsPath,
-  ensureLearningsFile,
   effectiveConfidence,
   loadLearnings,
   addLearning,

package/lib/loop-doctor.js

@@ -311,7 +311,7 @@ function missionLockPidAlive(pid) {
   }
 }
 
-function staleMissionLockFinding(root, nowIso, pidAlive = missionLockPidAlive) {
+function missionLockRecords(root, pidAlive = missionLockPidAlive) {
   const stateDir = path.join(root, '.atris', 'state');
   let names = [];
   try {
@@ -319,18 +319,21 @@ function staleMissionLockFinding(root, nowIso, pidAlive = missionLockPidAlive) {
   } catch {
     return [];
   }
-  const stale = [];
-  for (const name of names) {
+  return names.map((name) => {
     const file = path.join(stateDir, name);
     let lock = null;
     try { lock = JSON.parse(fs.readFileSync(file, 'utf8')); } catch {}
     const pid = Number(lock && lock.pid);
     if (!Number.isInteger(pid) || pid <= 0) {
-      stale.push({ lock: name, reason: 'unparseable', pid: null });
-    } else if (!pidAlive(pid)) {
-      stale.push({ lock: name, reason: 'dead-pid', pid });
+      return { lock: name, reason: 'unparseable', pid: null, stale: true };
     }
-  }
+    const alive = pidAlive(pid);
+    return { lock: name, reason: alive ? 'live-pid' : 'dead-pid', pid, stale: !alive };
+  });
+}
+
+function staleMissionLockFinding(root, nowIso, pidAlive = missionLockPidAlive) {
+  const stale = missionLockRecords(root, pidAlive).filter((lock) => lock.stale);
   if (!stale.length) return [];
   return [{
     kind: 'stale_mission_lock',
@@ -400,17 +403,8 @@ function scanLoopReceipts({ root = process.cwd(), now = new Date(), freshnessMs
 
 module.exports = {
   scanLoopReceipts,
-  repeatedFailureFindings,
-  authFailureFindings,
-  rewardFlatlineFinding,
-  zeroDueCapableFinding,
-  staleMissionLockFinding,
-  isDueCapableMission,
+  missionLockRecords,
   latestMissionRecords,
-  orderFindings,
   nonPositiveRewardPressure,
-  applyRewardPressure,
   FINDING_PRIORITY,
-  DEFAULT_RECEIPT_LIMIT,
-  DEFAULT_FINDING_FRESHNESS_MS,
 };

package/lib/manifest.js

@@ -251,9 +251,7 @@ module.exports = {
   buildManifest,
   computeLocalHashes,
   threeWayCompare,
-  getManifestPath,
   SKIP_DIRS,
   isIgnoredSyncPath,
   filterSyncFiles,
-  isSyncTextBuffer,
 };

package/lib/member-alive.js

@@ -227,6 +227,5 @@ function runAliveTick(name, opts = {}) {
 
 module.exports = {
   runAliveTick,
-  resolveMemberOperateScript,
   resolveAtrisBin,
 };

package/lib/member-switches.js

@@ -129,14 +129,9 @@ function memberArgFromArgv(argv = process.argv) {
 }
 
 module.exports = {
-  SWITCHES_REL,
-  switchesPath,
-  loadMemberSwitches,
-  saveMemberSwitches,
   isLocalMember,
   getMemberSwitch,
   isMemberAwake,
-  isMemberLoopAwake,
   setMemberAwake,
   setMemberLoopAwake,
   readLoopFlag,

package/lib/mission-artifact.js

@@ -498,7 +498,6 @@ function writeMissionArtifact(mission, options = {}) {
 }
 
 module.exports = {
-  buildMissionArtifactBlocks,
   missionArtifactPaths,
   writeMissionArtifact,
 };

package/lib/mission-protected-lane.js

@@ -0,0 +1,293 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { DENIED_TAGS } = require('./fleet');
+
+const PATH_SURFACES = [
+  ['middleware/proxy', /(?:^|[/_.-])(?:middleware|proxy)(?:[/_.-]|$)/i],
+  ['csp', /(?:^|[/_.-])csp(?:[/_.-]|$)/i],
+  ['auth', /(?:^|[/_.-])auth(?:entication|orization)?(?:[/_.-]|$)/i],
+  ['session', /(?:^|[/_.-])sessions?(?:[/_.-]|$)/i],
+  ['cookie', /(?:^|[/_.-])cookies?(?:[/_.-]|$)/i],
+  ['cors', /(?:^|[/_.-])cors(?:[/_.-]|$)/i],
+  ['sandbox', /(?:^|[/_.-])sandbox(?:[/_.-]|$)/i],
+  ['permission', /(?:^|[/_.-])permissions?(?:[/_.-]|$)/i],
+];
+
+const CONTENT_SURFACES = [
+  ['csp', /\bContent-Security-Policy\b/i],
+  ['csp nonce', /\bnonce\b/i],
+  ['iframe sandbox', /\bsandbox\s*=/i],
+  ['cookie', /\bSet-Cookie\b/i],
+  ['cors', /\bAccess-Control-Allow-[A-Za-z-]+\b/i],
+  ['public dynamic rendering', /\bforce-dynamic\b/i],
+  ['auth header', /\b(?:Authorization\s*[:=].*\bBearer\b|headers?\b[^\n]*\bauthorization\b|\bauthorization\b[^\n]*headers?\b)/i],
+];
+
+function normalizedTags(tags) {
+  const list = Array.isArray(tags) ? tags : [tags];
+  return list
+    .flatMap((tag) => String(tag || '').split(','))
+    .map((tag) => tag.trim().toLowerCase().replace(/_/g, '-'))
+    .filter(Boolean);
+}
+
+function changedPathsFromDiff(diff) {
+  const paths = [];
+  for (const line of String(diff || '').split(/\r?\n/)) {
+    const header = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+    if (header) {
+      paths.push(header[1], header[2]);
+      continue;
+    }
+    const file = line.match(/^(?:---|\+\+\+) (?:[ab]\/)?(.+)$/);
+    if (file && file[1] !== '/dev/null') paths.push(file[1]);
+  }
+  return Array.from(new Set(paths));
+}
+
+// Prose is not a protected surface. Docs, judge cards, wikis, journals and run
+// receipts routinely *describe* CSP or force-dynamic without changing any
+// behaviour — replaying this guard over 60 real commits, 5 of 6 hits were
+// markdown that merely mentioned the words. A guard that pauses on every judge
+// card gets switched off, which is worse than no guard. Content signals
+// therefore apply to code only; PATH signals still apply to every file.
+const CODE_FILE = /\.(?:[cm]?[jt]sx?|py|rb|go|rs|java|kt|swift|php|sh|bash|zsh|sql|ya?ml|toml|env)$/i;
+
+function isCodeFile(file) {
+  const f = String(file || '').trim();
+  if (!f || f === '/dev/null') return false;
+  if (/\.(?:md|mdx|markdown|txt|rst|adoc)$/i.test(f)) return false;
+  return CODE_FILE.test(f);
+}
+
+// Walk the diff file-by-file so a changed line is attributed to the file it
+// came from, then keep only lines from code files.
+function changedCodeLinesFromDiff(diff) {
+  const lines = [];
+  let inCode = false;
+  for (const line of String(diff || '').split(/\r?\n/)) {
+    const header = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+    if (header) {
+      inCode = isCodeFile(header[1]) || isCodeFile(header[2]);
+      continue;
+    }
+    if (/^(?:---|\+\+\+) /.test(line)) continue;
+    if (!inCode) continue;
+    if (/^[+-]/.test(line)) lines.push(line.slice(1));
+  }
+  return lines;
+}
+
+function matchProtectedMissionDiff(diff, { tags = [] } = {}) {
+  const matches = [];
+  const add = (surface, signal, detail) => {
+    if (matches.some((match) => match.surface === surface && match.signal === signal && match.detail === detail)) return;
+    matches.push({ surface, signal, detail });
+  };
+
+  for (const tag of normalizedTags(tags)) {
+    if (DENIED_TAGS.includes(tag)) add(tag, 'tag', tag);
+  }
+
+  for (const file of changedPathsFromDiff(diff)) {
+    for (const [surface, pattern] of PATH_SURFACES) {
+      if (pattern.test(file)) add(surface, 'path', file);
+    }
+  }
+
+  for (const line of changedCodeLinesFromDiff(diff)) {
+    for (const [surface, pattern] of CONTENT_SURFACES) {
+      if (pattern.test(line)) add(surface, 'content', 'changed line');
+    }
+  }
+
+  return {
+    protected: matches.length > 0,
+    surfaces: Array.from(new Set(matches.map((match) => match.surface))),
+    matches,
+  };
+}
+
+function runGitDiff(git, args, root) {
+  const result = git(args, root);
+  if (!result || result.error || result.status !== 0) {
+    const detail = result?.error?.message
+      || String(result?.stderr || result?.stdout || `git ${args.join(' ')} failed`).trim();
+    return { ok: false, detail: detail || 'git diff could not be read' };
+  }
+  return { ok: true, diff: String(result.stdout || '') };
+}
+
+function defaultGit(gitBin = 'git') {
+  return (args, root) => spawnSync(gitBin, args, {
+    cwd: root,
+    encoding: 'utf8',
+    timeout: 10000,
+  });
+}
+
+function readMissionDiff({
+  root = process.cwd(),
+  baseRef = '',
+  git = defaultGit(),
+  includeUnstaged = true,
+} = {}) {
+  const parts = [];
+  const staged = runGitDiff(git, ['diff', '--cached', '--no-ext-diff', '--unified=0', '--no-color', '--'], root);
+  if (!staged.ok) return staged;
+  parts.push(staged.diff);
+
+  if (includeUnstaged) {
+    const unstaged = runGitDiff(git, ['diff', '--no-ext-diff', '--unified=0', '--no-color', '--'], root);
+    if (!unstaged.ok) return unstaged;
+    parts.push(unstaged.diff);
+  }
+
+  if (baseRef) {
+    const committed = runGitDiff(git, ['diff', '--no-ext-diff', '--unified=0', '--no-color', baseRef, 'HEAD', '--'], root);
+    if (!committed.ok) return committed;
+    parts.push(committed.diff);
+  }
+
+  return { ok: true, diff: parts.filter(Boolean).join('\n') };
+}
+
+function protectedPause(reason, detail = {}) {
+  return {
+    ok: false,
+    allowed: false,
+    status: 'paused-for-review',
+    reason,
+    ...detail,
+  };
+}
+
+function unreadableMissionGuard(error) {
+  return protectedPause('mission diff could not be read; human review is required', {
+    unreadable: true,
+    detail: error?.message || String(error || 'unknown diff read failure'),
+    surfaces: ['unreadable diff'],
+    matches: [],
+  });
+}
+
+function inspectMissionProtectedDiff({
+  root = process.cwd(),
+  baseRef = '',
+  tags = [],
+  readDiff = readMissionDiff,
+  git,
+  includeUnstaged = true,
+} = {}) {
+  let read;
+  try {
+    read = readDiff({ root, baseRef, tags, git, includeUnstaged });
+  } catch (error) {
+    return unreadableMissionGuard(error);
+  }
+  if (!read || read.ok !== true) {
+    return unreadableMissionGuard(read?.detail);
+  }
+
+  const matched = matchProtectedMissionDiff(read.diff, { tags });
+  if (matched.protected) {
+    return protectedPause(`protected mission surface requires human review: ${matched.surfaces.join(', ')}`, {
+      unreadable: false,
+      surfaces: matched.surfaces,
+      matches: matched.matches,
+    });
+  }
+  return {
+    ok: true,
+    allowed: true,
+    status: 'clear',
+    reason: 'mission diff contains no protected surface',
+    unreadable: false,
+    surfaces: [],
+    matches: [],
+  };
+}
+
+function guardMissionLanding(options = {}) {
+  const inspection = inspectMissionProtectedDiff(options);
+  if (!inspection.allowed) return inspection;
+  const land = typeof options.land === 'function' ? options.land : () => ({ ok: true, landed: true });
+  return { ...land(), protected_lane_guard: inspection };
+}
+
+function gitSubcommand(args) {
+  const consumesValue = new Set(['-C', '-c', '--git-dir', '--work-tree', '--namespace', '--config-env']);
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = String(args[index] || '');
+    if (consumesValue.has(arg)) {
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith('-')) continue;
+    return arg;
+  }
+  return '';
+}
+
+function prepareMissionGitGuard({
+  root = process.cwd(),
+  tags = [],
+  pathValue = process.env.PATH || '',
+} = {}) {
+  const resolved = spawnSync('sh', ['-c', 'command -v git'], {
+    cwd: root,
+    encoding: 'utf8',
+    timeout: 5000,
+  });
+  const gitBin = String(resolved.stdout || '').trim();
+  if (resolved.status !== 0 || !gitBin) {
+    throw new Error('mission git guard could not resolve git');
+  }
+
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'atris-mission-git-'));
+  const wrapper = path.join(dir, 'git');
+  const modulePath = __filename;
+  const config = { root: path.resolve(root), tags: normalizedTags(tags), gitBin };
+  const source = [
+    '#!/usr/bin/env node',
+    "'use strict';",
+    `const { spawnSync } = require('child_process');`,
+    `const guard = require(${JSON.stringify(modulePath)});`,
+    `const config = ${JSON.stringify(config)};`,
+    gitSubcommand.toString(),
+    defaultGit.toString(),
+    `const args = process.argv.slice(2);`,
+    `if (gitSubcommand(args) === 'commit') {`,
+    `  const result = guard.inspectMissionProtectedDiff({ root: config.root, tags: config.tags, includeUnstaged: false, git: defaultGit(config.gitBin) });`,
+    `  if (!result.allowed) {`,
+    `    process.stderr.write(result.reason + '\\n');`,
+    `    process.exit(78);`,
+    `  }`,
+    `}`,
+    `const child = spawnSync(config.gitBin, args, { cwd: process.cwd(), stdio: 'inherit' });`,
+    `if (child.error) { process.stderr.write(child.error.message + '\\n'); process.exit(1); }`,
+    `process.exit(child.status == null ? 1 : child.status);`,
+    '',
+  ].join('\n');
+  fs.writeFileSync(wrapper, source, { encoding: 'utf8', mode: 0o755 });
+
+  return {
+    env: { ...process.env, PATH: `${dir}${path.delimiter}${pathValue}` },
+    pathPrefix: dir,
+    cleanup() {
+      try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
+    },
+  };
+}
+
+module.exports = {
+  matchProtectedMissionDiff,
+  unreadableMissionGuard,
+  inspectMissionProtectedDiff,
+  guardMissionLanding,
+  prepareMissionGitGuard,
+};

package/lib/mission-room.js

@@ -842,6 +842,4 @@ module.exports = {
   buildMissionRoom,
   writeMissionRoomReceipt,
   missionRoomLines,
-  writeThinkingMemory,
-  collectMissionRoomContext,
 };

package/lib/mission-runtime-loop.js

@@ -322,6 +322,5 @@ function readAtrisGoalState(cwd = process.cwd()) {
 module.exports = {
   missionRunIntentFromMessage,
   runRuntimeMissionLoop,
-  formatRuntimeMissionLoopReceipt,
   readAtrisGoalState,
 };

package/lib/next-moves.js

@@ -844,37 +844,19 @@ function nextMoves(root = process.cwd(), limit = 3) {
 module.exports = {
   moveId,
   norm,
-  titleKey,
   isGenericInboxPlaceholder,
-  WEIGHT,
   SELF_IMPROVEMENT_SEED_TITLE,
-  cleanSuggestedTargetTitle,
-  suggestedTargetFromReportText,
   latestSuggestedTarget,
-  parseInboxTitles,
-  cleanInboxMoveTitle,
   readRoadmapOpenItems,
-  readWaitingWishCards,
-  readActionableMissionCards,
-  readActiveMissions,
-  readUnreviewedShippedWishCards,
-  readDreamCards,
   markDreamCardConsumed,
-  dreamCardId,
   readEndgameMove,
-  readActiveTasks,
-  isInternalNextMoveTask,
   readHandledTaskTitles,
   latestInboxItems,
   todayInboxItems,
-  gatherCandidates,
   pickNextMoves,
-  readNextParked,
   parkNextCard,
   nextCards,
-  addMissionOnlyFallback,
   nextMoves,
-  readDecisions,
   recordDecision,
   seedInboxFromMove,
   pickRoadmapSeed,

package/lib/official-cli-integration.js

@@ -166,9 +166,5 @@ function createOfficialCliCommand(config) {
 
 module.exports = {
   createOfficialCliCommand,
-  ensureBinary,
-  hasHelp,
-  matchCommand,
   printHelp,
-  runAuthCheck,
 };

package/lib/orb-context.js

@@ -455,7 +455,8 @@ async function collectOrbContext(root, { threads = [], now = Date.now() } = {})
 }
 
 // The accumulate-context flywheel: each chosen option appends one visible line to the
-// project's now.md. Append-only; creates now.md on first choice.
+// project's operating truth at atris/now.md. Append-only; creates the file on first
+// choice. (It used to write <root>/now.md, a stray file nothing reads.)
 async function appendOrbChoice(root, label, when = new Date()) {
   const safeRoot = typeof root === 'string' && root ? path.resolve(root) : null;
   const cleanLabel = cleanTitle(label, 120);
@@ -463,7 +464,10 @@ async function appendOrbChoice(root, label, when = new Date()) {
   const day = when.toISOString().slice(0, 10);
   const line = `orb: ${cleanLabel} · ${day}\n`;
   try {
-    await fs.promises.appendFile(path.join(safeRoot, 'now.md'), line, 'utf8');
+    const nowPath = fs.existsSync(path.join(safeRoot, 'atris'))
+      ? path.join(safeRoot, 'atris', 'now.md')
+      : path.join(safeRoot, 'now.md'); // pre-init workspaces keep the old spot
+    await fs.promises.appendFile(nowPath, line, 'utf8');
     return { ok: true, line: line.trim() };
   } catch (error) {
     return { ok: false, error: String((error && error.message) || error) };
@@ -471,7 +475,6 @@ async function appendOrbChoice(root, label, when = new Date()) {
 }
 
 module.exports = {
-  buildOrbContext,
   collectOrbContext,
   appendOrbChoice,
 };

package/lib/orb-scorecard.js

@@ -217,7 +217,6 @@ function parseOrbScorecardDays(args = []) {
 module.exports = {
   DAY_MS,
   DEFAULT_DAYS,
-  emptyOrbScorecard,
   readOrbScorecard,
   renderOrbScorecard,
   parseOrbScorecardDays,

package/lib/outbound-send-gate.js

@@ -153,13 +153,7 @@ function prepareOutboundSendTextOrExit(channel, args = [], options = {}) {
 }
 
 module.exports = {
-  OutboundArtifactGateError,
-  assertOutboundSendAllowed,
   assertOutboundSendAllowedOrExit,
-  defaultGateOptions,
   extractOutboundGateOptions,
-  parseOutboundSendArgs,
   prepareOutboundSendTextOrExit,
-  readOutboundBodyFile,
-  shouldRunOutboundGate,
 };

package/lib/permission-grants.js

@@ -277,17 +277,11 @@ async function syncGrants({ apiRequestJson, token, file, endpoint = GRANTS_SYNC_
 
 module.exports = {
   GRANTS_SCHEMA,
-  GRANTS_SYNC_ENDPOINT,
-  grantsFilePath,
-  parseArgv,
-  commandIsGrantable,
   loadGrants,
   saveGrants,
   addGrant,
   revokeGrant,
   matchGrant,
   recordUse,
-  normalizeRemoteGrant,
-  mergeRemoteGrants,
   syncGrants,
 };

package/lib/policy-lessons.js

@@ -320,12 +320,10 @@ function syncLessonsMd(root, mined) {
 }
 
 module.exports = {
-  AGENT_ACTOR_PATTERN,
   VERIFY_COMMAND_PATTERN,
   loadHistory,
   mineProofPolicy,
   policyHintsForProof,
-  policyLessonsPath,
   readPolicyLessons,
   writePolicyLessons,
   syncLessonsMd,