atris 3.57.3 → 3.58.5

package/commands/x-search.js

@@ -1,26 +1,44 @@
 '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,
+  printLearnerCheckGate,
+  proveSavedLearnerBaseline,
+} = 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, then hands off to atris youtube search (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 +51,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 +79,8 @@ function parseSearchArgs(argv = []) {
     mode: 'search',
     help: false,
     json: false,
+    save: false,
+    unsave: false,
     query: null,
     limit: null,
     daysBack: null,
@@ -75,6 +98,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 +138,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 +152,7 @@ function parsePersonArgs(argv = []) {
     mode: 'person',
     help: false,
     json: false,
+    save: false,
     name: null,
     handle: null,
     company: null,
@@ -139,6 +171,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 +218,53 @@ function parsePersonArgs(argv = []) {
   return options;
 }
 
+function parseUnsaveArgs(argv = []) {
+  const args = [...argv];
+  const options = {
+    mode: 'unsave',
+    help: false,
+    json: false,
+    source: null,
+    sources: [],
+  };
+
+  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 === '--json') {
+      options.json = true;
+    } else if (arg === '--unsave') {
+      continue;
+    } else if (arg.startsWith('-')) {
+      throw new Error(`Unknown option: ${arg}`);
+    } else {
+      options.sources.push(arg);
+      if (!options.source) options.source = arg;
+    }
+  }
+
+  if (options.help) return options;
+  if (!options.sources.length) 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);
 }
 
@@ -258,6 +334,12 @@ function creditsWereRefunded(credits) {
   return typeof credits.refunded === 'number' && credits.refunded > 0;
 }
 
+function creditsRefundedExplicitly(credits) {
+  if (!credits) return false;
+  if (credits.refunded === true) return true;
+  return typeof credits.refunded === 'number' && credits.refunded > 0;
+}
+
 function formatCreditsLines(credits) {
   const lines = [];
   if (credits.used !== undefined || credits.remaining !== undefined) {
@@ -332,23 +414,182 @@ function xSearchApplySource(options) {
   return options?.query;
 }
 
+function quoteYoutubeSearchQuery(source) {
+  return `"${String(source || '').replace(/"/g, '')}"`;
+}
+
+function printYoutubeSearchNext(source, output) {
+  if (!source) return;
+  output(`next: atris youtube search ${quoteYoutubeSearchQuery(source)}`);
+}
+
+const EMPTY_YOUTUBE_SEARCH_NEXT = 'next: atris youtube search " "';
+
+function printEmptyYoutubeSearchNext(output) {
+  output(EMPTY_YOUTUBE_SEARCH_NEXT);
+}
+
 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 unsaveTargets(options) {
+  if (Array.isArray(options?.sources) && options.sources.length) return options.sources;
+  const single = options?.source || options?.query;
+  return single ? [single] : [];
+}
+
+function runXSearchUnsave(options, deps = {}) {
+  const output = deps.output || ((line = '') => console.log(line));
+  const targets = unsaveTargets(options);
+  if (!targets.length) {
+    output('usage: atris x-search unsave <query-or-source>');
+    return 2;
+  }
+  let code = 0;
+  for (const target of targets) {
+    const status = unsaveXSearch(target, deps);
+    if (status !== 0) code = status;
+  }
+  if (code === 0 && options.json !== true && deps.json !== true) {
+    printEmptyYoutubeSearchNext(output);
+  }
+  return code;
+}
+
+function saveRichXSearch({ cwd, source, text, now } = {}) {
+  const lesson = xSearchLessonFromText(text);
+  if (isThinTeachLesson(lesson)) {
+    return { thin: true, brief: null, packRel: null, lesson };
+  }
+  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, lesson };
+}
+
+function ensureXSearchApply({ cwd, source, packRel, now, output } = {}) {
+  const pack = packRel || (source ? xSearchExperimentRel(source) : null);
+  const slug = pack ? path.basename(pack) : null;
   return applyGate.ensureApply({
     cwd,
     source,
     rel: source ? xSearchApplyRel(source) : null,
     now,
     output,
-    incompleteMessage: APPLY_NEXT_MESSAGE,
+    incompleteMessage: slug
+      ? `next: atris experiments keep ${slug}`
+      : 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 +648,10 @@ async function xSearchCommand(argv = process.argv.slice(3), deps = {}) {
     return 0;
   }
 
+  if (options.mode === 'unsave' || options.unsave) {
+    return runXSearchUnsave(options, deps);
+  }
+
   let status = 0;
   try {
     const data = await runXSearch(options, deps);
@@ -416,16 +661,58 @@ 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({
-        cwd: deps.cwd || process.cwd(),
-        source: xSearchApplySource(options),
-        now: deps.applyNow,
-        output,
+    if (!hasResults) {
+      if (
+        !options.json
+        && !options.save
+        && !creditsRefundedExplicitly(xSearchCredits(data))
+      ) {
+        printEmptyYoutubeSearchNext(output);
+      }
+      status = 2;
+    } else if (options.save) {
+      const source = xSearchApplySource(options);
+      const cwd = deps.cwd || process.cwd();
+      const saved = saveRichXSearch({
+        cwd,
+        source,
+        text: xSearchContent(data),
+        now: deps.applyNow || deps.now,
       });
+      if (saved.thin) {
+        output(TEACH_THIN_REFUSE);
+        status = 2;
+      } else {
+        const ensureApply = deps.ensureApply || ensureXSearchApply;
+        const applyCode = ensureApply({
+          cwd,
+          source,
+          packRel: saved.packRel,
+          now: deps.applyNow || deps.now,
+          output,
+        });
+        if (deps.ensureApply) {
+          status = applyCode;
+        } else {
+          const baseline = proveSavedLearnerBaseline({
+            cwd,
+            applyRel: source ? xSearchApplyRel(source) : null,
+            lesson: saved.lesson,
+            output,
+            json: options.json === true,
+          });
+          status = baseline !== 0 ? baseline : applyCode;
+        }
+      }
     } else {
-      status = 2;
+      const lesson = xSearchLessonFromText(xSearchContent(data));
+      const json = options.json === true;
+      if (!json && !isThinTeachLesson(lesson)) {
+        applyGate.hintEphemeralApply(output, 'x-search');
+      }
+      printLearnerCheckGate(output, lesson, { includeCheck: true, json });
+      if (!json) printYoutubeSearchNext(xSearchApplySource(options), output);
+      status = 0;
     }
   } catch (err) {
     output(err.message);
@@ -439,12 +726,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,
 };

package/commands/xp.js

@@ -6,6 +6,7 @@ const path = require('path');
 const crypto = require('crypto');
 const { spawnSync } = require('child_process');
 const { hasFlag: hasExactFlag } = require('../lib/arg-parser');
+const { treeHashFor } = require('../lib/tree-hash');
 
 const DEFAULT_GRAPH_DAYS = 365;
 const MAX_SYNC_GRAPH_DAYS = 370;
@@ -22,7 +23,7 @@ const CODEX_STATE_FILE = path.join(os.homedir(), '.codex', 'state_5.sqlite');
 
 // Default single-workspace XP root. Local XP reads task_episodes.jsonl (written
 // by task-db at the resolved workspace root) and writes its projection beside
-// it, so the `--workspace` default must resolve the same shared root — otherwise
+// it, so the `--workspace` default must resolve the same shared root, otherwise
 // `xp --local` from a subdir (e.g. backend/) read the wrong/empty episodes and
 // split the projection into a nested .atris. Explicit --workspace still wins;
 // the multi-root roster path (discoverCareerXpWorkspaces) is untouched. Falls
@@ -908,7 +909,7 @@ function readTaskEpisodeTail(episodePath, cursorPath, options = {}) {
   }
 }
 
-function receiptFromTaskEpisode(episode) {
+function receiptFromTaskEpisode(episode, treeHash) {
   const episodeId = episode?.episode_id;
   const label = episode?.rl?.label;
   const rejected = label === 'rework_requested' || label === 'rejected';
@@ -924,6 +925,7 @@ function receiptFromTaskEpisode(episode) {
 
   return {
     schema: 'atris.career_xp_receipt.v1',
+    tree_hash: treeHash,
     receipt_id: `task_review:${episodeId}${rejected ? ':rejected' : ''}`,
     source: 'atris-cli',
     source_type: 'task_review',
@@ -1071,10 +1073,11 @@ function collectLocalXpProjectionState(args = [], { write = true } = {}) {
     && fileSize(episodePath) > 0
     && fileSize(receiptsPath) === 0;
   const tail = readTaskEpisodeTail(episodePath, cursorPath, { forceReset: replayFromStart });
+  const treeHash = write && tail.episodes.length ? treeHashFor(workspace) : null;
   const seen = new Set(existingChain.receipts.map(receipt => receipt.receipt_id).filter(Boolean));
   let previousHash = existingChain.integrity.head_hash || null;
   const newReceipts = tail.episodes
-    .map(receiptFromTaskEpisode)
+    .map((episode) => receiptFromTaskEpisode(episode, treeHash))
     .filter(Boolean)
     .filter((receipt) => {
       if (seen.has(receipt.receipt_id)) return false;