atris 3.57.3 → 3.58.5

package/commands/close.js

@@ -23,6 +23,7 @@ const FAILED_TASK_BATCH_PREFIX = 'tasks:failed:';
 const PROBE_TIMEOUT_MS = 60 * 1000;
 const PROBE_HOLD_GAP_MS = 60 * 60 * 1000;
 const PROBE_STOP_AFTER_FAILED_CHECKS = 2;
+const MAX_OPEN_FLAGS = 10;
 
 function ledgerPath(cwd = process.cwd()) {
   return path.join(cwd, LEDGER_RELATIVE_PATH);
@@ -144,6 +145,15 @@ function foldEvents(events, options = {}) {
       flag.why = event.why || '';
     } else if (event.kind === 'snoozed') {
       flag.snoozed_until = event.until || null;
+    } else if (event.kind === 'parked') {
+      flag.status = 'parked';
+      flag.parked_at = event.parked_at || eventTime(event);
+      flag.why = normalizeSpaces(event.why || 'parked by request');
+    } else if (event.kind === 'reopened') {
+      flag.status = 'open';
+      flag.reopened_at = eventTime(event);
+      delete flag.parked_at;
+      delete flag.why;
     } else if (event.kind === 'escalated') {
       const day = event.day || (event.at ? String(event.at).slice(0, 10) : null);
       if (day && !flag.escalated_days.includes(day)) flag.escalated_days.push(day);
@@ -223,6 +233,12 @@ function openFlags(cwd = process.cwd(), options = {}) {
   return foldEvents(readEvents(cwd), options).filter((flag) => flag.status === 'open');
 }
 
+function parkedFlags(cwd = process.cwd(), options = {}) {
+  return foldEvents(readEvents(cwd), options)
+    .filter((flag) => flag.status === 'parked')
+    .sort((a, b) => (parseDate(b.parked_at) || 0) - (parseDate(a.parked_at) || 0));
+}
+
 function ownerWaitRank(flag) {
   return /^(you|me|operator|human|keshav)$/.test(String(flag.owner || '').toLowerCase()) ? 0 : 1;
 }
@@ -264,6 +280,16 @@ function listLine(flag) {
   return parts.join(', ');
 }
 
+function parkedLine(flag) {
+  const what = trimSentenceEnd(flag.what.toLowerCase());
+  const day = flag.parked_at ? String(flag.parked_at).slice(0, 10) : 'unknown date';
+  return `${what}, parked ${day}, ${trimSentenceEnd(flag.why || 'parked by request').toLowerCase()}`;
+}
+
+function migratedParkLine(flag) {
+  return `parked ${trimSentenceEnd(flag.what).toLowerCase()}: ${trimSentenceEnd(flag.why).toLowerCase()}.`;
+}
+
 function sweepLine(flag) {
   const what = trimSentenceEnd(flag.what.toLowerCase());
   const closeCondition = trimSentenceEnd(flag.close_condition.toLowerCase());
@@ -325,9 +351,12 @@ function publicFlag(flag) {
 }
 
 function printHelp() {
-  console.log('usage: atris close <add|list|done|dissolve|snooze|sweep|scan|check>');
-  console.log('add "<what>" [--owner x] [--lane life|business|code] [--ttl 7] [--when "<condition>"] [--source y] [--probe "<cmd that fails now>"]');
+  console.log('usage: atris close <add|list|park|parked|reopen|done|dissolve|snooze|sweep|scan|check>');
+  console.log('add "<what>" [--owner x] [--lane life|business|code] [--ttl 7] [--when "<condition>"] [--source y] [--probe "<cmd that fails now>"] [--replace <id>]');
   console.log('list [--json] [--lane x]');
+  console.log('park <id> [--why "..."]');
+  console.log('parked [--json]');
+  console.log('reopen <id> [--replace <id>]');
   console.log('done <id> [--proof "..."]  (a probed incident closes only after its probe holds)');
   console.log('check [id] [--json]  (run live probes; failing probe = old theory still live)');
   console.log('dissolve <id> --why "..."');
@@ -336,6 +365,58 @@ function printHelp() {
   console.log('scan [--json]');
 }
 
+function appendParkedEvent(flag, cwd, now, why, options = {}) {
+  const at = now.toISOString();
+  const event = {
+    kind: 'parked',
+    at,
+    id: flag.id,
+    parked_at: at,
+    why: normalizeSpaces(why || 'parked by request'),
+  };
+  if (options.automatic) event.automatic = true;
+  appendEvent(event, cwd);
+  return {
+    id: flag.id,
+    what: flag.what,
+    parked_at: at,
+    why: event.why,
+  };
+}
+
+function slotCapError(flags) {
+  const fullest = flags
+    .slice()
+    .sort(compareOpenFlags)
+    .slice(0, 3)
+    .map((flag) => trimSentenceEnd(flag.what).toLowerCase())
+    .join(', ');
+  const names = fullest ? ` the fullest loops are ${fullest}.` : '';
+  return new Error(`ten open loops is the cap.${names} park one first or use --replace <id>`);
+}
+
+function makeRoomForOpenFlag(cwd, now, replaceId, incomingWhat) {
+  const flags = openFlags(cwd, { now });
+  const hasReplacement = replaceId !== undefined;
+  if (hasReplacement && (replaceId === true || !normalizeSpaces(replaceId))) {
+    throw new Error('--replace needs an id');
+  }
+  if (!hasReplacement) {
+    if (flags.length >= MAX_OPEN_FLAGS) throw slotCapError(flags);
+    return null;
+  }
+  if (flags.length > MAX_OPEN_FLAGS) throw slotCapError(flags);
+
+  const replacement = flags.find((flag) => flag.id === replaceId);
+  if (!replacement) throw new Error(`${replaceId} is not open`);
+  return appendParkedEvent(
+    replacement,
+    cwd,
+    now,
+    `replaced to make room for ${trimSentenceEnd(incomingWhat).toLowerCase()}`
+  );
+}
+
 function commandAdd(args, context = {}) {
   const { positional, options } = parseArgs(args);
   const what = normalizeSpaces(positional.join(' '));
@@ -366,6 +447,8 @@ function commandAdd(args, context = {}) {
     probeExit = result.exit_code;
   }
 
+  makeRoomForOpenFlag(context.cwd, now, options.replace, what);
+
   const openedAt = now.toISOString();
   const event = {
     kind: 'opened',
@@ -389,7 +472,7 @@ function commandAdd(args, context = {}) {
   return 0;
 }
 
-// atris close check [id] — run the live probes on open incidents. This is the
+// atris close check [id]: run the live probes on open incidents. This is the
 // first move for any session entering an area: if a probe still fails, the
 // recorded theory is still live; do not diagnose fresh. After
 // PROBE_STOP_AFTER_FAILED_CHECKS failing re-checks the verdict is automatic:
@@ -461,21 +544,88 @@ function commandCheck(args, context = {}) {
   return anyFailing ? 1 : 0;
 }
 
+function hasRunnableNextAction(flag) {
+  if (flag.probe) return true;
+  return /\b(accept|add|approve|book|build|call|check|choose|close|confirm|deploy|dissolve|email|fix|merge|pay|publish|reply|resolve|retry|review|run|send|ship|sign|test|update|verify|write)\b/.test(canonicalWhat(flag.what));
+}
+
+function hasMachineCheckableClose(flag) {
+  if (flag.probe) return true;
+  if (canonicalWhat(flag.close_condition).includes('source store resolves')) return true;
+  return /^(experiment|lesson|mission|pulse|task|usage|watch):/.test(canonicalWhat(flag.source));
+}
+
+function migrationReason(flag, duplicateIds) {
+  if (ownerWaitRank(flag) === 0) return 'waiting on a human';
+  if (!hasRunnableNextAction(flag)) return 'no runnable next action';
+  if (!hasMachineCheckableClose(flag)) return 'no machine-checkable close condition';
+  if (duplicateIds.has(flag.id)) return 'duplicates another open loop';
+  return '';
+}
+
+function compareOldestFlags(a, b) {
+  const aOpened = parseDate(a.opened_at) || 0;
+  const bOpened = parseDate(b.opened_at) || 0;
+  if (aOpened !== bOpened) return aOpened - bOpened;
+  return a.id.localeCompare(b.id);
+}
+
+function migrateOpenSlots(cwd = process.cwd(), now = new Date(), options = {}) {
+  const flags = openFlags(cwd, { now });
+  const excess = flags.length - MAX_OPEN_FLAGS;
+  const shouldWrite = options.dryRun !== true && options.write !== false && options.readOnly !== true;
+  if (excess <= 0 || !shouldWrite) return [];
+
+  const byWhat = new Map();
+  for (const flag of flags) {
+    const key = canonicalWhat(flag.what);
+    if (!byWhat.has(key)) byWhat.set(key, []);
+    byWhat.get(key).push(flag);
+  }
+  const duplicateIds = new Set(
+    Array.from(byWhat.values())
+      .filter((group) => group.length > 1)
+      .flat()
+      .map((flag) => flag.id)
+  );
+
+  const preferred = [];
+  const fallback = [];
+  for (const flag of flags.slice().sort(compareOldestFlags)) {
+    const why = migrationReason(flag, duplicateIds);
+    if (why) preferred.push({ flag, why });
+    else fallback.push({ flag, why: 'oldest loop above the active slot cap' });
+  }
+
+  return preferred.concat(fallback).slice(0, excess).map(({ flag, why }) => (
+    appendParkedEvent(flag, cwd, now, why, { automatic: true })
+  ));
+}
+
 function commandList(args, context = {}) {
   const { options } = parseArgs(args);
   const lane = options.lane ? String(options.lane).toLowerCase() : null;
   if (lane && !VALID_LANES.has(lane)) throw new Error('lane must be business, life, or code');
 
+  const now = context.now ? new Date(context.now) : new Date();
+  const autoClosed = autoCloseResolvedTaskReviewFlags(context.cwd, now);
+  const autoParked = migrateOpenSlots(context.cwd, now);
   let flags = openFlags(context.cwd, { now: context.now });
   if (lane) flags = flags.filter((flag) => flag.lane === lane);
   flags.sort(compareOpenFlags);
 
   if (options.json) {
-    printJson({ open: flags.map(publicFlag) });
+    const payload = { open: flags.map(publicFlag) };
+    if (autoClosed.length > 0) payload.auto_closed = autoClosed.map(publicTaskReviewClosed);
+    if (autoParked.length > 0) payload.auto_parked = autoParked;
+    printJson(payload);
     return 0;
   }
 
+  autoClosed.forEach((item) => console.log(taskReviewClosedLine(item)));
+  autoParked.forEach((flag) => console.log(migratedParkLine(flag)));
   if (flags.length === 0) {
+    if (autoClosed.length > 0) return 0;
     console.log('nothing open.');
     return 0;
   }
@@ -484,6 +634,50 @@ function commandList(args, context = {}) {
   return 0;
 }
 
+function commandPark(args, context = {}) {
+  const { positional, options } = parseArgs(args);
+  const id = positional[0];
+  if (!id) throw new Error('id is required');
+  const flag = requireOpenFlag(id, context);
+  const now = context.now ? new Date(context.now) : new Date();
+  const why = options.why === true ? undefined : options.why;
+  appendParkedEvent(flag, context.cwd, now, why);
+  console.log(`parked ${id}`);
+  return 0;
+}
+
+function commandParked(args, context = {}) {
+  const { options } = parseArgs(args);
+  const flags = parkedFlags(context.cwd, { now: context.now });
+  if (options.json) {
+    printJson({ parked: flags.map(publicFlag) });
+    return 0;
+  }
+  if (flags.length === 0) {
+    console.log('nothing parked.');
+    return 0;
+  }
+  flags.forEach((flag) => console.log(parkedLine(flag)));
+  return 0;
+}
+
+function commandReopen(args, context = {}) {
+  const { positional, options } = parseArgs(args);
+  const id = positional[0];
+  if (!id) throw new Error('id is required');
+  const flag = parkedFlags(context.cwd, { now: context.now }).find((item) => item.id === id);
+  if (!flag) throw new Error(`${id} is not parked`);
+  const now = context.now ? new Date(context.now) : new Date();
+  makeRoomForOpenFlag(context.cwd, now, options.replace, flag.what);
+  appendEvent({
+    kind: 'reopened',
+    at: now.toISOString(),
+    id,
+  }, context.cwd);
+  console.log(`reopened ${id}`);
+  return 0;
+}
+
 function requireOpenFlag(id, context = {}) {
   const flag = openFlags(context.cwd, { now: context.now }).find((item) => item.id === id);
   if (!flag) throw new Error(`${id} is not open`);
@@ -559,6 +753,8 @@ function commandSnooze(args, context = {}) {
 // one escalated event per overdue flag per day, return the resulting state.
 function sweepState(cwd = process.cwd(), now = new Date(), options = {}) {
   const today = isoDateOnly(now);
+  const autoClosed = autoCloseResolvedTaskReviewFlags(cwd, now);
+  const autoParked = migrateOpenSlots(cwd, now, options);
   let flags = openFlags(cwd, { now });
   const overdue = flags.filter((flag) => flag.overdue).sort(compareSweepFlags);
   const escalatedToday = [];
@@ -578,24 +774,39 @@ function sweepState(cwd = process.cwd(), now = new Date(), options = {}) {
   }
 
   flags = openFlags(cwd, { now });
-  return { open: flags.length, overdue, escalated_today: escalatedToday };
+  const result = { open: flags.length, overdue, escalated_today: escalatedToday };
+  if (autoClosed.length > 0) result.auto_closed = autoClosed;
+  if (autoParked.length > 0) result.auto_parked = autoParked;
+  return result;
 }
 
 function commandSweep(args, context = {}) {
   const { options } = parseArgs(args);
   const now = context.now ? new Date(context.now) : new Date();
-  const { open, overdue, escalated_today: escalatedToday } = sweepState(context.cwd, now);
+  const {
+    open,
+    overdue,
+    escalated_today: escalatedToday,
+    auto_closed: autoClosed = [],
+    auto_parked: autoParked = [],
+  } = sweepState(context.cwd, now);
 
   if (options.json) {
-    printJson({
+    const payload = {
       open,
       overdue: overdue.length,
       escalated_today: escalatedToday,
-    });
+    };
+    if (autoClosed.length > 0) payload.auto_closed = autoClosed.map(publicTaskReviewClosed);
+    if (autoParked.length > 0) payload.auto_parked = autoParked;
+    printJson(payload);
     return 0;
   }
 
+  autoClosed.forEach((item) => console.log(taskReviewClosedLine(item)));
+  autoParked.forEach((flag) => console.log(migratedParkLine(flag)));
   if (overdue.length === 0) {
+    if (autoClosed.length > 0) return 0;
     console.log('nothing is overdue.');
     return 0;
   }
@@ -682,7 +893,7 @@ function pulseLivenessState(cwd, now) {
 // decommissioned or intermittent loop leaves stale receipts frozen; without a
 // guard the last N finished ticks stay net-negative forever and the flag can
 // never clear (no fresh positive receipt arrives). It also must not treat a
-// scattered set — e.g. one tick today plus five from days ago — as a "run":
+// scattered set, e.g. one tick today plus five from days ago, as a "run":
 // summing rewards across a multi-day gap is meaningless. So we only consider
 // finished ticks from the last few days and require a full window of them; a
 // silent or sparse loop is the pulse-liveness sensor's concern, and here it
@@ -830,7 +1041,11 @@ function taskSource(task) {
 
 function taskResolved(task) {
   const status = normalizeSpaces(task && task.status).toLowerCase();
-  return status === 'done' || status === 'accepted';
+  const review = reviewObject(task);
+  const metadata = task && task.metadata && typeof task.metadata === 'object' ? task.metadata : {};
+  const approval = normalizeSpaces(review.approval_status || metadata.approval_status).toLowerCase();
+  return ['done', 'accepted', 'closed'].includes(status)
+    || ['accepted', 'approved', 'done', 'closed'].includes(approval);
 }
 
 function reviewObject(task) {
@@ -938,7 +1153,15 @@ function shortText(text, maxLength = 70) {
   return clipped || value.slice(0, maxLength).trim();
 }
 
-function appendOpenedFromSource({ what, owner = 'operator', lane = 'code', ttlDays = 3, source }, cwd, now) {
+function appendOpenedFromSource({
+  what,
+  owner = 'operator',
+  lane = 'code',
+  ttlDays = 3,
+  source,
+  probe,
+  closeCondition = 'the source store resolves it',
+}, cwd, now) {
   const event = {
     kind: 'opened',
     at: now.toISOString(),
@@ -948,25 +1171,79 @@ function appendOpenedFromSource({ what, owner = 'operator', lane = 'code', ttlDa
     lane: VALID_LANES.has(lane) ? lane : 'code',
     opened_at: now.toISOString(),
     ttl_days: Number(ttlDays) || 3,
-    close_condition: 'the source store resolves it',
+    close_condition: normalizeSpaces(closeCondition) || 'the source store resolves it',
     source,
   };
+  const normalizedProbe = normalizeSpaces(probe || '');
+  if (normalizedProbe) event.probe = normalizedProbe;
   appendEvent(event, cwd);
   return event;
 }
 
-function appendClosedFromSource(flag, cwd, now, note) {
+function upsertSourceFlag(candidate, cwd = process.cwd(), options = {}) {
+  const now = options.now ? new Date(options.now) : new Date();
+  const source = normalizeSpaces(candidate && candidate.source);
+  if (!source) throw new Error('source is required');
+
+  const flags = openFlags(cwd, { now });
+  const existing = flags.find((flag) => flag.source === source);
+  if (!existing && flags.length >= MAX_OPEN_FLAGS) {
+    return { filed: false, refreshed: false, reason: 'full' };
+  }
+
+  const event = appendOpenedFromSource({ ...candidate, source }, cwd, now);
+  return { filed: true, refreshed: Boolean(existing), event };
+}
+
+function appendClosedFromSource(flag, cwd, now, note, proof = RESOLVED_IN_SOURCE_PROOF) {
   const event = {
     kind: 'closed',
     at: now.toISOString(),
     id: flag.id,
-    proof: RESOLVED_IN_SOURCE_PROOF,
+    proof,
   };
   if (note) event.note = note;
   appendEvent(event, cwd);
   return event;
 }
 
+function taskReviewFlag(flag) {
+  return flag && flag.source && flag.source.startsWith('task:')
+    && canonicalWhat(flag.what).includes('has waited in review too long');
+}
+
+function autoCloseResolvedTaskReviewFlags(cwd = process.cwd(), now = new Date()) {
+  const tasksById = latestById(readTaskProjection(cwd));
+  if (tasksById.size === 0) return [];
+
+  const closed = [];
+  const flags = foldEvents(readEvents(cwd), { now })
+    .filter((flag) => flag.status === 'open' || flag.status === 'parked')
+    .filter(taskReviewFlag);
+  for (const flag of flags) {
+    const watchedTaskId = flag.source.slice('task:'.length);
+    const task = tasksById.get(watchedTaskId);
+    if (!task || !taskResolved(task)) continue;
+    const ref = taskRef(task) || watchedTaskId;
+    const proof = `task ${ref.toLowerCase()} is closed in task projection`;
+    const event = appendClosedFromSource(flag, cwd, now, null, proof);
+    closed.push({ flag, event, task_ref: ref });
+  }
+  return closed;
+}
+
+function taskReviewClosedLine(item) {
+  return `auto-closed review reminder for task ${item.task_ref.toLowerCase()}.`;
+}
+
+function publicTaskReviewClosed(item) {
+  return {
+    id: item.event.id,
+    task_ref: item.task_ref,
+    proof: item.event.proof,
+  };
+}
+
 function scanState(cwd = process.cwd(), options = {}) {
   const now = options.now ? new Date(options.now) : new Date();
   const tasks = readTaskProjection(cwd);
@@ -1247,7 +1524,7 @@ function run(args = [], context = {}) {
       printHelp();
       return 0;
     }
-    // `close <sub> --help` is a help request, not a run — sweep and scan mutate
+    // `close <sub> --help` is a help request, not a run, sweep and scan mutate
     // the ledger (escalations, auto-closes), so never execute a subcommand just
     // to show usage.
     if (rest.includes('--help') || rest.includes('-h')) {
@@ -1256,6 +1533,9 @@ function run(args = [], context = {}) {
     }
     if (subcommand === 'add') return commandAdd(rest, context);
     if (subcommand === 'list') return commandList(rest, context);
+    if (subcommand === 'park') return commandPark(rest, context);
+    if (subcommand === 'parked') return commandParked(rest, context);
+    if (subcommand === 'reopen') return commandReopen(rest, context);
     if (subcommand === 'done') return commandDone(rest, context);
     if (subcommand === 'dissolve') return commandDissolve(rest, context);
     if (subcommand === 'snooze') return commandSnooze(rest, context);
@@ -1277,6 +1557,8 @@ module.exports = {
   closeIdForWhat,
   foldEvents,
   openFlags,
+  parkedFlags,
+  upsertSourceFlag,
   ledgerPath,
   readEvents,
   sweepLine,

package/commands/compile.js

@@ -1,5 +1,5 @@
 /**
- * Atris Compile — learn like AI, run like code.
+ * Atris Compile: learn like AI, run like code.
  *
  * The compile loop: execution records → compile-to-deterministic-code →
  * statistical backtest → gated promote. The LLM is only in the build path;
@@ -328,7 +328,7 @@ function deepEqual(a, b) {
 function loadRunner(root, name) {
   const p = runnerPath(root, name);
   if (!fs.existsSync(p)) {
-    throw new Error(`no compiled artifact at ${path.relative(root, p)} — run "atris compile build ${name}" first`);
+    throw new Error(`no compiled artifact at ${path.relative(root, p)}, run "atris compile build ${name}" first`);
   }
   const resolved = require.resolve(p);
   delete require.cache[resolved]; // always load the latest compiled version
@@ -344,7 +344,7 @@ function loadRunner(root, name) {
 async function runBacktest(root, name, options = {}) {
   const records = readRecords(root, name);
   if (records.length === 0) {
-    throw new Error(`no execution records for "${name}" — add some with "atris compile record ${name} --input ... --output ..."`);
+    throw new Error(`no execution records for "${name}", add some with "atris compile record ${name} --input ... --output ..."`);
   }
   const runner = loadRunner(root, name);
   const manifest = readManifest(root, name) || defaultManifest(name);
@@ -395,7 +395,7 @@ async function runBacktest(root, name, options = {}) {
 function promoteProcess(root, name, options = {}) {
   const manifest = readManifest(root, name);
   if (!manifest) {
-    throw new Error(`no manifest for "${name}" — compile and backtest it first`);
+    throw new Error(`no manifest for "${name}", compile and backtest it first`);
   }
   if (options.threshold !== undefined) {
     // the only way to change the standing gate: deliberate, at promote time
@@ -403,13 +403,13 @@ function promoteProcess(root, name, options = {}) {
   }
   const bt = manifest.backtest;
   if (!bt) {
-    throw new Error(`"${name}" has no backtest — run "atris compile backtest ${name}" first`);
+    throw new Error(`"${name}" has no backtest, run "atris compile backtest ${name}" first`);
   }
   if (bt.version !== manifest.version) {
-    throw new Error(`backtest is for version ${bt.version} but current version is ${manifest.version} — re-run the backtest`);
+    throw new Error(`backtest is for version ${bt.version} but current version is ${manifest.version}, re-run the backtest`);
   }
   if (bt.accuracy < manifest.threshold) {
-    throw new Error(`backtest accuracy ${(bt.accuracy * 100).toFixed(2)}% is below the ${(manifest.threshold * 100).toFixed(2)}% gate (${bt.passed}/${bt.total}) — not promoting`);
+    throw new Error(`backtest accuracy ${(bt.accuracy * 100).toFixed(2)}% is below the ${(manifest.threshold * 100).toFixed(2)}% gate (${bt.passed}/${bt.total}), not promoting`);
   }
   manifest.status = 'active';
   manifest.promotedAt = new Date().toISOString();
@@ -436,10 +436,10 @@ Write the compiled artifact to ${runRel} with this exact contract:
 - CommonJS module exporting { run }: \`module.exports = { run };\`
 - \`run(input)\` takes one input value and returns the output (sync return or promise both fine)
 - deterministic: no network calls, no Date.now()/new Date() in outputs, no randomness, no environment reads
-- Node.js built-ins only — zero npm dependencies
+- Node.js built-ins only, zero npm dependencies
 - handle malformed input by throwing a clear Error, never by guessing
 
-The artifact will be verified by replaying every execution record through run() and requiring near-perfect accuracy, so generalize the rules — do not hardcode a lookup table of the sample records.
+The artifact will be verified by replaying every execution record through run() and requiring near-perfect accuracy, so generalize the rules, do not hardcode a lookup table of the sample records.
 
 Reply [COMPILE_COMPLETE] when ${runRel} is written.`;
 }
@@ -448,7 +448,7 @@ function executeBuild(root, name, options = {}) {
   const { verbose = false, timeout = 600000, notes = '', cmdOverride } = options;
   const records = readRecords(root, name);
   if (records.length === 0) {
-    throw new Error(`no execution records for "${name}" — record real runs first, then compile`);
+    throw new Error(`no execution records for "${name}", record real runs first, then compile`);
   }
 
   if (!cmdOverride) {
@@ -526,7 +526,7 @@ function formatAccuracy(accuracy) {
 function printBacktest(name, result, failureCount, manifest) {
   console.log(`backtest ${name} v${result.version}: ${result.passed}/${result.total} passed (${formatAccuracy(result.accuracy)}), gate ${formatAccuracy(result.threshold)}`);
   if (result.total < LOW_RECORD_WARNING) {
-    console.log(`note: only ${result.total} record${result.total === 1 ? '' : 's'} — accuracy means more with ${LOW_RECORD_WARNING}+`);
+    console.log(`note: only ${result.total} record${result.total === 1 ? '' : 's'}, accuracy means more with ${LOW_RECORD_WARNING}+`);
   }
   if (failureCount > 0) {
     console.log(`${failureCount} mismatch${failureCount === 1 ? '' : 'es'}. first ${Math.min(failureCount, 3)}:`);
@@ -675,7 +675,7 @@ function showCompileHelp() {
   console.log('Server commands require --agent <id> and Atris auth from atris login or ATRIS_TOKEN.');
   console.log('Loop: record real runs -> build -> backtest -> promote -> exec --record');
   console.log('When backtest accuracy drops below the gate, the process is marked drifted');
-  console.log('and a recompile is suggested — self-healing against process drift.');
+  console.log('and a recompile is suggested, self-healing against process drift.');
   console.log('');
 }
 
@@ -830,7 +830,7 @@ async function compileCommand(subcommand, ...rawArgs) {
     }
     const manifest = readManifest(root, name);
     if (manifest && manifest.status === 'drifted') {
-      console.error(`warning: ${name} is marked drifted — outputs may be stale. recompile with "atris compile build ${name}"`);
+      console.error(`warning: ${name} is marked drifted, outputs may be stale. recompile with "atris compile build ${name}"`);
     }
     const runner = loadRunner(root, name);
     const output = await runner.run(input);