atris 3.36.0 → 3.37.1

package/bin/atris.js

@@ -14,6 +14,15 @@ const os = require('os');
 const crypto = require('crypto');
 const PACKAGE_JSON_PATH = path.join(__dirname, '..', 'package.json');
 
+// Exit without truncating piped stdout: process.exit() drops whatever is still
+// queued in the pipe buffer (large outputs died at 512-byte boundaries). Let
+// the event loop drain naturally; an unref'd timer forces exit if a stray
+// handle keeps the process alive.
+function exitWhenFlushed(code) {
+  process.exitCode = code;
+  setTimeout(() => process.exit(code), 3000).unref();
+}
+
 let CLI_VERSION = 'unknown';
 try {
   const pkgRaw = fs.readFileSync(PACKAGE_JSON_PATH, 'utf8');
@@ -2100,8 +2109,8 @@ if (command === 'init') {
     .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
 } else if (command === 'youtube') {
   require('../commands/youtube').youtubeCommand(process.argv.slice(3))
-    .then(() => process.exit(0))
-    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
+    .then(() => exitWhenFlushed(0))
+    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); exitWhenFlushed(1); });
 } else if (command === 'run') {
   const args = process.argv.slice(3);
   if (args[0] === 'logs') {

package/commands/mission.js

@@ -1487,7 +1487,7 @@ function missionMetricLine(mission, indent = '  ') {
   return [`${indent}metric: ${metric}${last === null ? '' : ` (last: ${last})`}`];
 }
 
-function renderMemberNowMarkdown(owner, missions) {
+function renderMemberNowMarkdown(owner, missions, root = process.cwd()) {
   const lines = [
     '# Now',
     '',
@@ -1505,6 +1505,8 @@ function renderMemberNowMarkdown(owner, missions) {
     lines.push('');
     lines.push(`- id: ${mission.id}`);
     lines.push(`- status: ${missionHumanStatusText(mission)}`);
+    const debtLine = missionVerificationDebtLine(missionVerificationDebt(mission, root));
+    if (debtLine) lines.push(`- ${debtLine}`);
     lines.push(`- cadence: ${mission.cadence}`);
     lines.push(`- runner: ${mission.runner}${mission.model ? ` (${mission.model})` : ''}`);
     lines.push(`- lane: ${mission.lane}`);
@@ -1533,7 +1535,7 @@ function renderMemberMissionState(owner, root = process.cwd()) {
   const missions = listMissions(root).filter((mission) => mission.owner === owner);
   const nowPath = path.join(dir, 'now.md');
   removeLegacyGeneratedMissionViews(dir);
-  fs.writeFileSync(nowPath, renderMemberNowMarkdown(owner, missions), 'utf8');
+  fs.writeFileSync(nowPath, renderMemberNowMarkdown(owner, missions, root), 'utf8');
   return { missionPath, nowPath };
 }
 
@@ -2006,6 +2008,39 @@ function missionRunTrustedObjective(rawObjective, room, target) {
   return missionRunPreflightObjective(rawObjective, room, room?.owner || 'mission-lead');
 }
 
+const MISSION_RUN_SHAPING_STOPWORDS = new Set([
+  'should', 'would', 'could', 'with', 'that', 'this', 'from', 'into',
+  'atris', 'mission', 'room', 'just', 'work', 'works',
+]);
+
+function missionRunSignificantTokens(value) {
+  return String(value || '')
+    .toLowerCase()
+    .replace(/[^a-z]+/g, ' ')
+    .split(/\s+/)
+    .filter((token) => token.length >= 4 && !MISSION_RUN_SHAPING_STOPWORDS.has(token));
+}
+
+function guardMissionRunShaping(rawObjective, shapedObjective, selectedTarget) {
+  const rawTokens = missionRunSignificantTokens(rawObjective);
+  const shapedTokens = new Set(missionRunSignificantTokens(shapedObjective));
+  const sharesSignificantToken = [...rawTokens].some((token) => shapedTokens.has(token));
+  if (rawTokens.length < 4 || sharesSignificantToken) {
+    return { shapedObjective, selectedTarget, shapingRejected: false, shapingRejectedReason: '' };
+  }
+
+  const rejectedTitle = missionRunConcreteTitle(selectedTarget?.title)
+    || missionRunConcreteTitle(shapedObjective)
+    || 'untitled shaping';
+  const rejectedRef = selectedTarget?.ref || selectedTarget?.task_id || 'no ref';
+  return {
+    shapedObjective: rawObjective,
+    selectedTarget: null,
+    shapingRejected: true,
+    shapingRejectedReason: `shaping rejected: "${rejectedTitle}" (${rejectedRef}) shares no significant tokens with the raw objective`,
+  };
+}
+
 function buildMissionRunRoomPreflight(rawObjective, args = [], options = {}) {
   if (!shouldMissionRunRoomPreflight(rawObjective, args)) return null;
   const root = options.root || process.cwd();
@@ -2034,27 +2069,33 @@ function buildMissionRunRoomPreflight(rawObjective, args = [], options = {}) {
   const shapedObjective = trustedRun
     ? missionRunTrustedObjective(rawObjective, written.room, selectedTarget)
     : missionRunPreflightObjective(rawObjective, written.room, ownerResolution.owner);
-  const taskSpineRequired = !selectedTarget && (explicitPreflight || signalPreflight);
+  const shaping = guardMissionRunShaping(rawObjective, shapedObjective, selectedTarget);
+  const acceptedTarget = shaping.selectedTarget;
+  const taskSpineRequired = !acceptedTarget && (explicitPreflight || signalPreflight);
   return {
     schema: 'atris.mission_run_preflight.v1',
     source: 'mission_room',
     raw_objective: rawObjective,
-    shaped_objective: shapedObjective,
-    visible_goal_objective: shapedObjective,
+    shaped_objective: shaping.shapedObjective,
+    visible_goal_objective: shaping.shapedObjective,
     room_name: written.room.name,
     room_receipt_path: written.relativePath,
     owner: ownerResolution.owner,
     owner_resolution: ownerResolution.reason,
     trusted_run: trustedRun,
-    selected_target: selectedTarget ? {
-      title: selectedTarget.title,
-      source: selectedTarget.source,
-      task_id: selectedTarget.task_id || null,
-      ref: selectedTarget.ref || null,
-      why: selectedTarget.why || '',
+    selected_target: acceptedTarget ? {
+      title: acceptedTarget.title,
+      source: acceptedTarget.source,
+      task_id: acceptedTarget.task_id || null,
+      ref: acceptedTarget.ref || null,
+      why: acceptedTarget.why || '',
     } : null,
+    ...(shaping.shapingRejected ? {
+      shaping_rejected: true,
+      shaping_rejected_reason: shaping.shapingRejectedReason,
+    } : {}),
     task_spine_required: taskSpineRequired,
-    next_action: selectedTarget
+    next_action: acceptedTarget
       ? 'run one proof tick for the selected existing task'
       : (taskSpineRequired ? 'attach task spine, then run one proof tick' : 'run one proof tick'),
   };
@@ -4749,6 +4790,68 @@ function missionTimelineTickIndex(tick) {
   return Number.isInteger(tickIndex) && tickIndex > 0 ? tickIndex : null;
 }
 
+// A tick's verification state, made first-class so an unchecked increment reads
+// as a red in `atris mission report` and now.md instead of hiding inside a
+// receipt. A ran tick with no verifier result is the debt this surfaces: the
+// tick was recorded but nothing was checked, so the increment is unproven.
+function missionTickVerification(tick) {
+  const ran = !!tick && typeof tick === 'object' && tick.status === 'ran';
+  if (tick && tick.verifier_passed === true) {
+    return { verified: true, state: 'verified', unchecked: false };
+  }
+  if (tick && tick.verifier_passed === false) {
+    return { verified: false, state: 'failed', unchecked: false };
+  }
+  return { verified: false, state: ran ? 'unchecked' : 'skipped', unchecked: ran };
+}
+
+// Roll every ran tick for a mission into a verification-debt tally. `unchecked`
+// counts ran ticks that recorded no verifier result at all — the "tick recorded
+// but nothing was checked" red the report and now.md rollup surface and count
+// against the mission.
+function missionVerificationDebt(mission, root = process.cwd()) {
+  const paths = statePaths(root);
+  let files = [];
+  try {
+    files = fs.readdirSync(paths.runsDir)
+      .filter((file) => file.startsWith('mission-') && file.endsWith('.json'))
+      .map((file) => path.join(paths.runsDir, file));
+  } catch {
+    files = [];
+  }
+  let ran = 0;
+  let verified = 0;
+  let unchecked = 0;
+  const seen = new Set();
+  for (const file of files) {
+    let receipt = null;
+    try {
+      receipt = JSON.parse(fs.readFileSync(file, 'utf8'));
+    } catch {
+      continue;
+    }
+    if (!receipt || receipt.mission_id !== mission.id) continue;
+    for (const tick of missionReceiptTicks(receipt)) {
+      if (!tick || tick.status !== 'ran') continue;
+      const key = `${tick.tick_index || ''}:${tick.finished_at || tick.started_at || ''}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      ran += 1;
+      const verification = missionTickVerification(tick);
+      if (verification.verified) verified += 1;
+      if (verification.unchecked) unchecked += 1;
+    }
+  }
+  return { ran, verified, unchecked };
+}
+
+// One glanceable red line for a mission carrying unverified-tick debt. Empty
+// when every ran tick was checked, so clean missions stay quiet.
+function missionVerificationDebtLine(debt) {
+  if (!debt || !debt.unchecked) return '';
+  return `unverified ticks: ${debt.unchecked} of ${debt.ran} ran no check ⚠ — treat those increments as unproven`;
+}
+
 function missionReportTimeline(mission, root = process.cwd(), limit = 6) {
   const paths = statePaths(root);
   let files = [];
@@ -4778,11 +4881,14 @@ function missionReportTimeline(mission, root = process.cwd(), limit = 6) {
       const key = `${tick.tick_index || ''}:${at}:${summary}`;
       if (seen.has(key)) continue;
       seen.add(key);
+      const verification = missionTickVerification(tick);
       items.push({
         at,
         tick_index: missionTimelineTickIndex(tick),
         title: missionTimelineTitle(tick, summary),
         summary,
+        verified: verification.verified,
+        verify_state: verification.state,
         receipt_path: receiptPath,
       });
     }
@@ -5040,6 +5146,7 @@ function missionReportFor(mission, root = process.cwd()) {
   const receipt = readMissionReceipt(verifierReceiptPath, root);
   const explicitWorkerReceipt = readMissionReceipt(mission.worker_receipt_path, root);
   const timeline = missionReportTimeline(mission, root);
+  const verificationDebt = missionVerificationDebt(mission, root);
   const workerCheckedIn = Boolean(explicitWorkerReceipt) || timeline.length > 0;
   const workerReceiptPath = mission.worker_receipt_path || (receipt && verifierReceiptPath) || null;
   const verifierPassed = mission.verifier_result && mission.verifier_result.passed === true;
@@ -5060,6 +5167,7 @@ function missionReportFor(mission, root = process.cwd()) {
       : missionHumanStatusText(mission),
     budget_continuation: budgetContinuation,
     operator_outcome: operatorOutcome,
+    verification: verificationDebt,
     worker: mission.worker || missionWorkerLabel(mission),
     worker_summary: missionWorkerSummary(mission, receipt),
     timeline,
@@ -5114,6 +5222,9 @@ function reportMission(args) {
         `  What happened: ${report.operator_outcome}`,
         `  Worker: ${report.worker}`,
         `  Worker summary: ${report.worker_summary}`,
+        ...(report.verification && report.verification.unchecked ? [
+          `  ⚠ Unverified: ${report.verification.unchecked} of ${report.verification.ran} tick(s) recorded but ran no check; treat those increments as unproven.`,
+        ] : []),
         ...(report.timeline && report.timeline.length ? [
           '  Timeline:',
           ...report.timeline.map((item) => `    - ${report.budget_continuation ? item.summary : item.title}`),
@@ -10587,6 +10698,11 @@ module.exports = {
   missionLandingLines,
   missionVerifierCheckedText,
   missionVerifierHighLevelTestText,
+  missionTickVerification,
+  missionVerificationDebt,
+  missionVerificationDebtLine,
+  missionReportFor,
+  renderMemberNowMarkdown,
   buildEngineVerifyPrompt,
   engineVerifierResultFromRun,
   missionFullBudgetRemainingSeconds,

package/commands/task.js

@@ -5533,7 +5533,11 @@ function cmdReviews(args) {
   }
   approvalItems.forEach((item, index) => {
     if (index > 0) console.log('');
-    console.log(`${index + 1}. ${gateForHuman(item.title, { title: item.title }).text}`);
+    const ref = item.display_id || taskRef(item.id);
+    const badge = item.evidence?.any_forced
+      ? ' [evidence:forced]'
+      : item.evidence?.all_passing ? ' [evidence:passing]' : '';
+    console.log(`${index + 1}. ${gateForHuman(item.title, { title: item.title }).text} (${ref})${badge}`);
     if (item.landing) {
       taskReviewLandingLines(item).forEach(line => console.log(line));
       if (verbose && item.result?.saved) console.log(`   saved: ${item.result.saved}`);

package/lib/ax-auto-lane.js

@@ -7,17 +7,35 @@ const GREETING_MAX_CHARS = 40;
 const DECISION_FACTOR_MIN_COMMAS = 3;
 const TRADEOFF_DEPTH_MIN_CHARS = 100;
 
-const LOOKUP_WORD_RE = /\b(?:what|who|when|where|list|show|define|convert)\b/i;
+// Anchored to the start: a lookup word mid-sentence is usually a subordinate
+// clause (my fan spins when i run tests), not a lookup.
+const LOOKUP_START_RE = /^(?:(?:please|pls|hey|hi|yo)[,: ]+)?(?:whats|whos|wheres|what|who|when|where|list|show|define)\b/i;
 // Words that turn a lookup-shaped message into a judgment call: never fast.
-const JUDGMENT_WORD_RE = /\b(?:should|tradeoffs?|better|best|recommend|worth)\b/i;
-const HEAVY_REASONING_RE = /\b(?:design(?:s|ed|ing)?|architect(?:s|ed|ing)?|prov(?:e|es|ed|ing)|analy(?:ze|zes|zed|zing|se|ses|sed|sing)|compar(?:e|es|ed|ing)|plan(?:s|ned|ning)?|sketch(?:es|ed|ing)?)\b/i;
+const JUDGMENT_WORD_RE = /\b(?:should|tradeoffs?|better|best|recommend|worth|good way)\b/i;
+const HEAVY_REASONING_RE = /\b(?:design(?:s|ed|ing)?|architect(?:s|ed|ing)?|prov(?:e|es|ed|ing)|analy(?:ze|zes|zed|zing|se|ses|sed|sing)|compar(?:e|es|ed|ing)|plan(?:s|ned|ning)?|sketch(?:es|ed|ing)?)\b|\bwalk(?:s|ed|ing)? (?:me |us )?through\b/i;
 const DECISION_PHRASE_RE = /\b(?:should|whether|decide|deciding)\b/i;
 const ARGUE_BOTH_RE = /\bargue\b|\bboth sides\b|\bsteelman\b/i;
 const CODE_EDIT_RE = /\b(?:fix(?:es|ed|ing)?|refactor(?:s|ed|ing)?|renam(?:e|es|ed|ing)|debug(?:s|ged|ging)?)\b/i;
 const CODE_DIAGNOSIS_RE = /\bwhy\b|\bwrong\b|\bfail(?:s|ed|ing)?\b|\bresolv(?:e|es|ed|ing)?\b|\bbroken\b|\bnot work/i;
-const CODE_CONTEXT_RE = /```|(?:^|\n)\s*(?:traceback\b|(?:[a-z]+)?(?:error|exception):|at\s+\S+\s+\()/im;
+const CODE_CONTEXT_RE = /```|\bregexp?\b|(?:^|\n)\s*(?:traceback\b|(?:[a-z]+)?(?:error|exception):|at\s+\S+\s+\()/im;
 const ERROR_EXPLAIN_RE = /\bexplain (?:this|the) error\b|\bwhat does (?:this|the) error mean\b/i;
+// Yes/no capability checks are lookups even without a lookup keyword.
+const YESNO_LOOKUP_RE = /^(?:does|is|are|can|do)\b/i;
+// Tiny how-do-i asks are muscle-memory lookups; longer ones are advice.
+const HOWTO_LOOKUP_RE = /^how (?:do|does|did) (?:i|we|you)\b/i;
+const HOWTO_LOOKUP_MAX_CHARS = 40;
+const YESNO_LOOKUP_MAX_CHARS = 80;
+// Troubleshooting language means advice, not recall: keep it out of fast.
+const TROUBLE_RE = /\bfail(?:s|ed|ing)?\b|\bcrash(?:es|ed|ing)?\b|\bbroken\b|\bnot working\b/i;
+const WEIGHING_WORD_RE = /\b(?:consider|weigh|rank|estimate|think (?:about|through))\b/i;
+const WEIGHING_FACTOR_MIN_COMMAS = 2;
 const TRANSFORM_START_RE = /^(?:convert|summarize|translate)\b/i;
+// Reshaping pasted content is editing work, not analysis; question marks
+// inside the paste do not make it a multi-question ask.
+const TRANSFORM_INTENT_RE = /^(?:turn|clean up|rewrite|reword|compress|tighten|polish)\b/i;
+// Possessives point at workspace context the model must gather first.
+const OWN_CONTEXT_RE = /\b(?:our|my)\b/i;
+const SPANISH_LOOKUP_RE = /^(?:que|qu\u00e9|cual|cu\u00e1l|quien|qui\u00e9n|cuando|cu\u00e1ndo|donde|d\u00f3nde|como|c\u00f3mo)\b/i;
 const GREETING_RE = /^(?:hey|hi|hello|yo|thanks|thank you|ok|okay|cool|nice|got it|great|perfect|yep|no worries)\b/i;
 
 function threshold(value, fallback) {
@@ -35,11 +53,15 @@ function pickLane(message, opts = {}) {
   if (text.length > longInputMinChars) {
     return { lane: 'max', reason: 'max fits this long input.' };
   }
+  if (TRANSFORM_INTENT_RE.test(text) && !HEAVY_REASONING_RE.test(text)) {
+    return { lane: 'pro', reason: 'pro fits reshaping the content you pasted.' };
+  }
   if (questionCount > 1) {
     return { lane: 'max', reason: 'max fits a request with multiple questions.' };
   }
   if (ARGUE_BOTH_RE.test(text)
-    || (DECISION_PHRASE_RE.test(text) && commaCount >= DECISION_FACTOR_MIN_COMMAS)) {
+    || (DECISION_PHRASE_RE.test(text) && commaCount >= DECISION_FACTOR_MIN_COMMAS)
+    || (WEIGHING_WORD_RE.test(text) && commaCount >= WEIGHING_FACTOR_MIN_COMMAS)) {
     return { lane: 'max', reason: 'max fits a decision weighing several factors.' };
   }
   if (HEAVY_REASONING_RE.test(text)) {
@@ -54,7 +76,12 @@ function pickLane(message, opts = {}) {
   if (ERROR_EXPLAIN_RE.test(text) && !hasCodeContext) {
     return { lane: 'fast', reason: 'fast fits a plain error explanation.' };
   }
-  if (TRANSFORM_START_RE.test(text) && text.length <= shortLookupMaxChars) {
+  if (SPANISH_LOOKUP_RE.test(text) && text.length <= shortLookupMaxChars
+    && !JUDGMENT_WORD_RE.test(text) && !TROUBLE_RE.test(text)) {
+    return { lane: 'fast', reason: 'fast fits this short lookup.' };
+  }
+  if (TRANSFORM_START_RE.test(text) && text.length <= shortLookupMaxChars
+    && !OWN_CONTEXT_RE.test(text)) {
     return { lane: 'fast', reason: 'fast fits this small transform.' };
   }
   if (GREETING_RE.test(text) && text.length <= GREETING_MAX_CHARS) {
@@ -63,9 +90,22 @@ function pickLane(message, opts = {}) {
   if (text.length > 0 && text.length <= TINY_MESSAGE_MAX_CHARS && !CODE_EDIT_RE.test(text)) {
     return { lane: 'fast', reason: 'fast fits this tiny message.' };
   }
+  if (text.length <= HOWTO_LOOKUP_MAX_CHARS
+    && HOWTO_LOOKUP_RE.test(text)
+    && !JUDGMENT_WORD_RE.test(text)
+    && !TROUBLE_RE.test(text)) {
+    return { lane: 'fast', reason: 'fast fits this quick how-to.' };
+  }
+  if (text.length <= YESNO_LOOKUP_MAX_CHARS
+    && YESNO_LOOKUP_RE.test(text)
+    && !JUDGMENT_WORD_RE.test(text)
+    && !TROUBLE_RE.test(text)) {
+    return { lane: 'fast', reason: 'fast fits this yes or no lookup.' };
+  }
   if (text.length <= shortLookupMaxChars
-    && LOOKUP_WORD_RE.test(text)
-    && !JUDGMENT_WORD_RE.test(text)) {
+    && LOOKUP_START_RE.test(text)
+    && !JUDGMENT_WORD_RE.test(text)
+    && !TROUBLE_RE.test(text)) {
     return { lane: 'fast', reason: 'fast fits this short factual lookup.' };
   }
   return { lane: 'pro', reason: 'pro fits this general request.' };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.36.0",
+  "version": "3.37.1",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {