atris 3.57.3 → 3.57.4

package/commands/worktree.js

@@ -6,11 +6,14 @@ const { spawnSync } = require('child_process');
 const { hasFlag, readFlag } = require('../lib/arg-parser');
 const { stampLatestOpenBriefForWorktree } = require('../lib/brief-ledger');
 const { isConductorArtifact } = require('../lib/conductor-artifacts');
+const close = require('./close');
 
 const REGEN_ADAPTER_FILES = ['AGENTS.md', 'CLAUDE.md', 'GEMINI.md'];
 const COMMAND_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
 const GIT_OID_PATTERN = /^[0-9a-f]{40,64}$/;
 const ONE_LAP_PROOF_REF_PATTERN = /^refs\/atris\/one-lap\/([0-9a-f]{40,64})$/;
+const DAY_MS = 24 * 60 * 60 * 1000;
+const SHIP_HEALTH_SOURCE = 'ship-health:experiments-daily';
 
 function runGit(args, { cwd = process.cwd(), check = true, timeout } = {}) {
   const result = spawnSync('git', args, { cwd, encoding: 'utf8', timeout });
@@ -672,6 +675,56 @@ function findPrimaryRoot(root) {
   return worktrees[0]?.path || root;
 }
 
+function shellQuote(value) {
+  const text = String(value || '');
+  if (/^[A-Za-z0-9_./:@+-]+$/.test(text)) return text;
+  return `'${text.replace(/'/g, `'"'"'`)}'`;
+}
+
+function experimentHealthProbe(statePath) {
+  const script = [
+    "const fs=require('fs')",
+    'const state=JSON.parse(fs.readFileSync(process.argv[1],\'utf8\'))',
+    'const last=Date.parse(state.last_run_date)',
+    `process.exit(Number.isFinite(last)&&Date.now()-last<=${DAY_MS}?0:1)`,
+  ].join(';');
+  return `${shellQuote(process.execPath)} -e ${shellQuote(script)} ${shellQuote(statePath)}`;
+}
+
+function runShipHealthCheck(workspaceRoot, options = {}) {
+  try {
+    const now = options.now ? new Date(options.now) : new Date();
+    const statePath = path.join(workspaceRoot, '.atris', 'state', 'experiments-daily.json');
+    const state = fs.existsSync(statePath)
+      ? JSON.parse(fs.readFileSync(statePath, 'utf8'))
+      : {};
+    const rawLastRunDate = state && state.last_run_date;
+    const lastRunMs = rawLastRunDate ? Date.parse(rawLastRunDate) : null;
+    if (rawLastRunDate && !Number.isFinite(lastRunMs)) {
+      throw new Error('experiment state date is unreadable');
+    }
+
+    const ageMs = Number.isFinite(lastRunMs) ? now.getTime() - lastRunMs : null;
+    if (ageMs !== null && ageMs <= DAY_MS) return { healthy: true, filed: false };
+
+    const days = ageMs === null ? 1 : Math.max(1, Math.floor(ageMs / DAY_MS));
+    console.log(`health check failed: no verified experiment in ${days} days. shipping still works, the metabolism does not.`);
+    const filed = close.upsertSourceFlag({
+      what: 'no verified experiment has run in over a day',
+      owner: 'operator',
+      lane: 'code',
+      ttlDays: 1,
+      source: SHIP_HEALTH_SOURCE,
+      closeCondition: 'a verified experiment ran within 24 hours',
+      probe: experimentHealthProbe(statePath),
+    }, workspaceRoot, { now });
+    return { healthy: false, ...filed };
+  } catch (error) {
+    console.log(`health check skipped: ${String(error && error.message || error).toLowerCase()}. shipping still works.`);
+    return { healthy: null, filed: false, error };
+  }
+}
+
 function shipWorktree(args) {
   if (hasFlag(args, '--help') || hasFlag(args, '-h') || args[0] === 'help') {
     shipHelp();
@@ -825,6 +878,7 @@ function shipWorktree(args) {
       }
     }
     console.log('pr: skipped (local mode)');
+    if (merge && !dryRun) runShipHealthCheck(primary || root);
     console.log('done: worktree shipped');
     return 0;
   }
@@ -870,6 +924,7 @@ function shipWorktree(args) {
       note: `worktree ship completed into ${targetRef}`,
     }, { worktree: root });
   } catch {}
+  if (merge && !dryRun) runShipHealthCheck(primary || root);
   console.log('done: worktree shipped');
   return 0;
 }
@@ -1219,5 +1274,6 @@ module.exports = {
   taskTokens,
   statusCounts,
   swarloClaim,
+  runShipHealthCheck,
   worktreeCommand,
 };

package/commands/x-search.js

@@ -1,26 +1,42 @@
 'use strict';
 
+const fs = require('fs');
+const path = require('path');
 const { apiRequestJson } = require('../utils/api');
 const { ensureBilledCommandAuth } = require('./auth');
 const applyGate = require('../lib/apply-gate');
+const {
+  fileTeachExperiment,
+  extractTeachNumbers,
+  extractTeachMechanisms,
+  isThinTeachLesson,
+  TEACH_THIN_REFUSE,
+} = require('./youtube');
 
 const DEFAULT_TIMEOUT_MS = 120000;
 const COST_HINT = '5 credits per search';
 const APPLY_NEXT_MESSAGE =
   'next: write one apply (change + receipt) for this query.';
+const KEEP_RULE = 'keep only if measure.py moves 0→1. scores 1 only when the fixture contains the check tokens.';
 
 function showXSearchHelp(output = console.log, commandName = 'atris x-search') {
   output('');
-  output(`Usage: ${commandName} "<query>" [--limit N] [--days N] [--json]`);
-  output(`       ${commandName} person --name <name> [--handle <h>] [--company <c>] [--context <text>] [--json]`);
+  output(`Usage: ${commandName} "<query>" [--limit N] [--days N] [--save] [--json]`);
+  output(`       ${commandName} person --name <name> [--handle <h>] [--company <c>] [--context <text>] [--save] [--json]`);
+  output(`       ${commandName} unsave <query-or-source>`);
   output('');
   output(`Search X/Twitter via Atris (${COST_HINT}).`);
   output('Requires login. Same auth path as atris youtube process.');
+  output('Prints to stdout. Rich ephemeral prints one apply next-step (no files).');
+  output('--save files a brief only when the result is rich.');
+  output('unsave deletes the filed brief, apply stub, and matching experiment pack (no paid calls).');
   output('Empty or failed search refunds the credits.');
   output('');
   output('Options:');
   output('  --limit <n>         Max results hint (search only)');
   output('  --days <n>          Only tweets from the last N days (search only)');
+  output('  --save              File brief, journal, apply; rich results mint a keep/revert experiment');
+  output('  --unsave            Delete filed brief, apply stub, and matching experiment pack (no paid calls)');
   output('  --json              Print the raw JSON response');
   output('  -h, --help          This help');
   output('');
@@ -33,7 +49,10 @@ function showXSearchHelp(output = console.log, commandName = 'atris x-search') {
   output('Examples:');
   output(`  ${commandName} "MCP agents"`);
   output(`  ${commandName} "MCP agents" --limit 5 --days 2`);
+  output(`  ${commandName} "MCP agents" --save`);
   output(`  ${commandName} person --name "Leah Bonvissuto" --handle leahbon`);
+  output(`  ${commandName} unsave "MCP agents"`);
+  output(`  ${commandName} --unsave "MCP agents"`);
   output('');
 }
 
@@ -58,6 +77,8 @@ function parseSearchArgs(argv = []) {
     mode: 'search',
     help: false,
     json: false,
+    save: false,
+    unsave: false,
     query: null,
     limit: null,
     daysBack: null,
@@ -75,6 +96,10 @@ function parseSearchArgs(argv = []) {
       options.help = true;
     } else if (arg === '--json') {
       options.json = true;
+    } else if (arg === '--save') {
+      options.save = true;
+    } else if (arg === '--unsave') {
+      options.unsave = true;
     } else if (arg === '--limit') {
       options.limit = parsePositiveInt(readValue(args, i, arg), '--limit');
       i++;
@@ -111,7 +136,11 @@ function parseSearchArgs(argv = []) {
   }
 
   if (options.help) return options;
-  if (!options.query) throw new Error('Missing query. Run "atris x-search --help".');
+  if (!options.query) {
+    throw new Error(options.unsave
+      ? 'usage: atris x-search unsave <query-or-source>'
+      : 'Missing query. Run "atris x-search --help".');
+  }
   return options;
 }
 
@@ -121,6 +150,7 @@ function parsePersonArgs(argv = []) {
     mode: 'person',
     help: false,
     json: false,
+    save: false,
     name: null,
     handle: null,
     company: null,
@@ -139,6 +169,8 @@ function parsePersonArgs(argv = []) {
       options.help = true;
     } else if (arg === '--json') {
       options.json = true;
+    } else if (arg === '--save') {
+      options.save = true;
     } else if (arg === '--name') {
       options.name = readValue(args, i, arg);
       i++;
@@ -184,11 +216,50 @@ function parsePersonArgs(argv = []) {
   return options;
 }
 
+function parseUnsaveArgs(argv = []) {
+  const args = [...argv];
+  const options = {
+    mode: 'unsave',
+    help: false,
+    source: null,
+  };
+
+  if (args.length === 0 || ['help', '--help', '-h'].includes(args[0])) {
+    if (args.length === 0) {
+      throw new Error('usage: atris x-search unsave <query-or-source>');
+    }
+    options.help = true;
+    return options;
+  }
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--help' || arg === '-h' || arg === 'help') {
+      options.help = true;
+    } else if (arg === '--unsave') {
+      continue;
+    } else if (arg.startsWith('-')) {
+      throw new Error(`Unknown option: ${arg}`);
+    } else if (!options.source) {
+      options.source = arg;
+    } else {
+      throw new Error(`Unexpected argument: ${arg}`);
+    }
+  }
+
+  if (options.help) return options;
+  if (!options.source) throw new Error('usage: atris x-search unsave <query-or-source>');
+  return options;
+}
+
 function parseXSearchArgs(argv = []) {
   const args = [...argv];
   if (args[0] === 'person') {
     return parsePersonArgs(args.slice(1));
   }
+  if (args[0] === 'unsave') {
+    return parseUnsaveArgs(args.slice(1));
+  }
   return parseSearchArgs(args);
 }
 
@@ -336,19 +407,138 @@ function xSearchApplyRel(source) {
   return applyGate.applySidecarRel('x-search', applyGate.applySlug(source));
 }
 
+function xSearchExperimentSlug(source) {
+  return `x-search-${applyGate.applySlug(source)}`;
+}
+
+function xSearchExperimentRel(source) {
+  return `atris/experiments/${xSearchExperimentSlug(source)}`;
+}
+
+function xSearchBriefRel(source) {
+  return `atris/wiki/briefs/x-search-${applyGate.applySlug(source)}.md`;
+}
+
 function xSearchHasResults(data) {
   return Boolean(xSearchContent(data)) || xSearchCitations(data).length > 0;
 }
 
-function ensureXSearchApply({ cwd, source, now, output } = {}) {
+function xSearchLessonFromText(text) {
+  const body = String(text || '');
+  return {
+    numbers: extractTeachNumbers(body),
+    mechanisms: extractTeachMechanisms(body),
+  };
+}
+
+function dateStamp(now) {
+  if (typeof now === 'string' && /^\d{4}-\d{2}-\d{2}/.test(now)) {
+    return now.slice(0, 10);
+  }
+  const value = now instanceof Date ? now : new Date(now || Date.now());
+  if (Number.isNaN(value.getTime())) return new Date().toISOString().slice(0, 10);
+  return value.toISOString().slice(0, 10);
+}
+
+function fileXSearchBrief({ cwd, source, text, now } = {}) {
+  try {
+    if (!source || !cwd) return null;
+    const wikiDir = path.join(cwd, 'atris', 'wiki');
+    if (!fs.existsSync(wikiDir)) return null;
+    const rel = xSearchBriefRel(source);
+    fs.mkdirSync(path.join(cwd, 'atris', 'wiki', 'briefs'), { recursive: true });
+    const date = dateStamp(now);
+    const heading = String(source).trim().toLowerCase() || 'x search';
+    const header = [
+      heading,
+      '',
+      `date: ${date}`,
+      `source: ${source}`,
+      'rail: atris x-search',
+    ].join('\n');
+    fs.writeFileSync(path.join(cwd, rel), `${header}\n\n${String(text || '').trim()}\n`);
+
+    const journalPath = path.join(cwd, 'atris', 'logs', date.slice(0, 4), `${date}.md`);
+    fs.mkdirSync(path.dirname(journalPath), { recursive: true });
+    let existing = '';
+    if (fs.existsSync(journalPath)) existing = fs.readFileSync(journalPath, 'utf8');
+    const line = `- [claimable] searched: ${heading} -> ${rel}`;
+    if (!existing.includes(line)) {
+      const prefix = existing && !existing.endsWith('\n') ? '\n' : '';
+      fs.writeFileSync(journalPath, `${existing}${prefix}${line}\n`);
+    }
+    return rel;
+  } catch {
+    return null;
+  }
+}
+
+function removeUnsaveRel(cwd, rel, removed) {
+  const abs = path.join(cwd, rel);
+  try {
+    if (!fs.existsSync(abs)) return;
+    const st = fs.lstatSync(abs);
+    if (st.isDirectory()) fs.rmSync(abs, { recursive: true, force: true });
+    else fs.unlinkSync(abs);
+    removed.push(rel);
+  } catch {
+    // already gone or unreadable: do not error
+  }
+}
+
+function unsaveXSearch(target, deps = {}) {
+  const output = deps.output || ((line = '') => console.log(line));
+  const cwd = deps.cwd || process.cwd();
+  const source = String(target || '').trim();
+  if (!source) {
+    output('usage: atris x-search unsave <query-or-source>');
+    return 2;
+  }
+  const briefRel = xSearchBriefRel(source);
+  const applyRel = xSearchApplyRel(source);
+  const packRel = xSearchExperimentRel(source);
+  const removed = [];
+  for (const rel of [briefRel, applyRel, packRel]) {
+    removeUnsaveRel(cwd, rel, removed);
+  }
+  if (!removed.length) {
+    output(`already gone: ${briefRel} and ${applyRel}`);
+    return 0;
+  }
+  output(`removed ${removed.join(' and ')}`);
+  return 0;
+}
+
+function saveRichXSearch({ cwd, source, text, now } = {}) {
+  const lesson = xSearchLessonFromText(text);
+  if (isThinTeachLesson(lesson)) {
+    return { thin: true, brief: null, packRel: null };
+  }
+  const brief = fileXSearchBrief({ cwd, source, text, now });
+  const packRel = fileTeachExperiment({
+    cwd,
+    lesson,
+    slug: source ? xSearchExperimentSlug(source) : null,
+    applyRel: source ? xSearchApplyRel(source) : null,
+  });
+  return { thin: false, brief, packRel };
+}
+
+function ensureXSearchApply({ cwd, source, packRel, now, output } = {}) {
+  const pack = packRel || (source ? xSearchExperimentRel(source) : null);
   return applyGate.ensureApply({
     cwd,
     source,
     rel: source ? xSearchApplyRel(source) : null,
     now,
     output,
-    incompleteMessage: APPLY_NEXT_MESSAGE,
+    incompleteMessage: pack
+      ? `next: apply ${pack}. keep only if measure.py moves 0→1`
+      : APPLY_NEXT_MESSAGE,
     required: false,
+    change: pack ? `apply ${pack}` : undefined,
+    receipt: pack ? KEEP_RULE : undefined,
+    journalLine: pack ? `- [claimable] apply: ${pack}. ${KEEP_RULE}` : undefined,
   });
 }
 
@@ -407,6 +597,10 @@ async function xSearchCommand(argv = process.argv.slice(3), deps = {}) {
     return 0;
   }
 
+  if (options.mode === 'unsave' || options.unsave) {
+    return unsaveXSearch(options.source || options.query, deps);
+  }
+
   let status = 0;
   try {
     const data = await runXSearch(options, deps);
@@ -416,16 +610,37 @@ async function xSearchCommand(argv = process.argv.slice(3), deps = {}) {
     } else {
       output(hasResults ? formatXSearchResult(data) : formatEmptyXSearchResult(data));
     }
-    if (hasResults) {
-      const ensureApply = deps.ensureApply || ensureXSearchApply;
-      status = ensureApply({
+    if (!hasResults) {
+      status = 2;
+    } else if (options.save) {
+      const source = xSearchApplySource(options);
+      const saved = saveRichXSearch({
         cwd: deps.cwd || process.cwd(),
-        source: xSearchApplySource(options),
-        now: deps.applyNow,
-        output,
+        source,
+        text: xSearchContent(data),
+        now: deps.applyNow || deps.now,
       });
+      if (saved.thin) {
+        output(TEACH_THIN_REFUSE);
+        status = 2;
+      } else {
+        const ensureApply = deps.ensureApply || ensureXSearchApply;
+        status = ensureApply({
+          cwd: deps.cwd || process.cwd(),
+          source,
+          packRel: saved.packRel,
+          now: deps.applyNow || deps.now,
+          output,
+        });
+      }
     } else {
-      status = 2;
+      if (
+        !options.json
+        && !isThinTeachLesson(xSearchLessonFromText(xSearchContent(data)))
+      ) {
+        applyGate.hintEphemeralApply(output, 'x-search');
+      }
+      status = 0;
     }
   } catch (err) {
     output(err.message);
@@ -439,12 +654,14 @@ async function xSearchCommand(argv = process.argv.slice(3), deps = {}) {
 
 module.exports = {
   DEFAULT_TIMEOUT_MS,
-  APPLY_NEXT_MESSAGE,
   parseXSearchArgs,
   buildSearchPayload,
   buildPersonPayload,
-  formatXSearchResult,
   xSearchHasResults,
   xSearchApplyRel,
+  xSearchBriefRel,
+  xSearchExperimentSlug,
+  xSearchExperimentRel,
+  unsaveXSearch,
   xSearchCommand,
 };