atris 3.82.11 → 3.82.14

package/commands/memory-live.js

@@ -0,0 +1,373 @@
+'use strict';
+
+// atris memory show, search, read, ls, remember, write, rm, usage, log, lesson
+// and agents: the person's Atris memory from any terminal, so any agent can
+// read it, search it and save to it. One request per command. The login and
+// network modules load only when a command needs the server.
+
+const fs = require('fs');
+const path = require('path');
+const live = require('../lib/memory-live');
+const { NOT_LOGGED_IN, oneLine, tokenFrom } = require('../lib/developer-api');
+
+const MAX_WRITE_BYTES = 1000000;
+const STDIN_WAIT_MS = 5000;
+const REMEMBER_MAX_CHARS = 1000;
+const REMEMBER_FILES = ['journal', 'now', 'learning'];
+const LEARNING_SECTIONS = ['want', 'understand', 'shaky'];
+
+class UsageError extends Error {}
+
+const enc = encodeURIComponent;
+
+function usageFor(sub) {
+  const line = live.USAGE_LINES[sub];
+  return `${line ? `usage:\n${line}\n` : ''}All memory commands: atris memory --help`;
+}
+
+// What went wrong, in words a person or an agent can act on.
+function plainError(result, auth = {}) {
+  const status = Number(result && result.status) || 0;
+  const raw = result ? result.error : null;
+  let detail;
+  if (Array.isArray(raw)) {
+    const first = raw[0] || {};
+    const field = Array.isArray(first.loc) ? first.loc.filter((part) => part !== 'body' && part !== 'query').join('.') : '';
+    detail = `Atris refused the request${field ? `, ${field}` : ''}: ${oneLine(first.msg || 'not valid')}`;
+  } else {
+    detail = oneLine(raw);
+  }
+  if (status === 0) return `could not reach Atris (${detail}). Check the connection and try again.`;
+  if (status === 401) return 'your Atris login was not accepted. Run: atris login';
+  if (status === 404 && detail === 'Not Found') {
+    return auth.scoped
+      ? 'this agent sign-in cannot reach Atris memory. Memory needs your own login: atris login'
+      : 'the Atris server does not have this memory command yet. Try again after it updates.';
+  }
+  if (status === 429) return 'Atris is getting too many requests right now. Wait a minute and try again.';
+  if (status >= 500) return `Atris had a problem (HTTP ${status}). Try again in a moment.`;
+  return detail;
+}
+
+async function defaultAuth() {
+  const { apiRequestJson } = require('../utils/api');
+  const { ensureFreshCredentials, decodeJwtClaims } = require('../utils/auth');
+  const creds = await ensureFreshCredentials(apiRequestJson);
+  const token = tokenFrom(creds);
+  const claims = token ? decodeJwtClaims(token) : null;
+  const scoped = Boolean(creds && (creds.auth_type === 'agent_client' || (claims && claims.type === 'agent_access')));
+  return { token, scoped };
+}
+
+function makeCall(deps, auth) {
+  const request = deps.apiRequestJson || require('../utils/api').apiRequestJson;
+  return async (pathname, options = {}) => {
+    const result = await request(pathname, { token: auth.token, timeoutMs: 30000, ...options });
+    if (result && result.ok) return result.data || {};
+    const error = new Error(plainError(result, auth));
+    error.status = result ? Number(result.status) || 0 : 0;
+    throw error;
+  };
+}
+
+// The whole of stdin, or null when nothing is piped in. Stops waiting after a
+// few seconds with no data, so an agent whose stdin is an idle pipe never hangs.
+function readStdin(waitMs = STDIN_WAIT_MS) {
+  const stdin = process.stdin;
+  if (stdin.isTTY) return Promise.resolve(null);
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let got = false;
+    const timer = setTimeout(() => {
+      if (got) return;
+      stdin.pause();
+      resolve(null);
+    }, waitMs);
+    stdin.on('data', (chunk) => { got = true; chunks.push(chunk); });
+    stdin.on('end', () => { clearTimeout(timer); resolve(Buffer.concat(chunks)); });
+    stdin.on('error', (error) => { clearTimeout(timer); reject(error); });
+  });
+}
+
+const utf8 = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+
+function agentName(ctx) {
+  return String(ctx.flags['--as'] || ctx.env.ATRIS_AGENT || '').trim();
+}
+
+function needAgent(ctx) {
+  const agent = agentName(ctx);
+  if (!agent) throw new UsageError('say which agent you are: --as <name>, or set ATRIS_AGENT once (like ATRIS_AGENT=codex)');
+  return agent;
+}
+
+function onePath(ctx, what) {
+  const [rel, extra] = ctx.words;
+  if (!rel) throw new UsageError(`name the ${what}, like wiki/people/sam.md`);
+  if (extra !== undefined) throw new UsageError(`give one path; "${extra}" is extra`);
+  return rel;
+}
+
+function numberFlag(ctx, name, read) {
+  const parsed = read(ctx.flags[name], name);
+  if (parsed.error) throw new UsageError(parsed.error);
+  return parsed.value;
+}
+
+const COMMANDS = {
+  show: {
+    check(ctx) {
+      if (ctx.words.length) throw new UsageError('show takes no words; it prints everything that matters now');
+    },
+    async run(ctx) {
+      const data = await ctx.call('/me/memory');
+      const text = live.showText(data);
+      return { data: { empty: Boolean(data.empty), files: data.files || {}, text }, lines: [text] };
+    },
+  },
+
+  search: {
+    check(ctx) {
+      const query = ctx.words.map((word) => word.trim()).filter(Boolean).join('|');
+      if (!query) throw new UsageError('say what to look for, like atris memory search "rent|lease"');
+      return { query, folder: ctx.flags['--in'] || '' };
+    },
+    async run(ctx, { query, folder }) {
+      const data = await ctx.call(`/memory/grep?q=${enc(query)}${folder ? `&folder=${enc(folder)}` : ''}`);
+      return { data: { query, folder, ...data }, lines: live.searchLines(query, data) };
+    },
+  },
+
+  read: {
+    check(ctx) {
+      const rel = onePath(ctx, 'file to read');
+      const from = numberFlag(ctx, '--from', live.positiveInt);
+      const count = numberFlag(ctx, '--lines', live.positiveInt);
+      if (ctx.flags['--raw'] && (from || count)) throw new UsageError('--raw prints the whole file; leave out --from and --lines');
+      return { rel, from: from || 1, count: count || 120 };
+    },
+    async run(ctx, { rel, from, count }) {
+      if (ctx.flags['--raw']) {
+        const data = await ctx.call(`/memory/file?path=${enc(rel)}`);
+        return { data, raw: String(data.text || '') };
+      }
+      const data = await ctx.call(`/memory/read?path=${enc(rel)}&start=${from}&count=${count}`);
+      return { data, lines: live.readLines({ path: rel, ...data }) };
+    },
+  },
+
+  ls: {
+    check(ctx) {
+      if (ctx.words.length > 1) throw new UsageError('give one folder, or none for the top');
+      return { folder: (ctx.words[0] || '').replace(/^\/+|\/+$/g, '') };
+    },
+    async run(ctx, { folder }) {
+      const data = await ctx.call(`/memory/ls?folder=${enc(folder)}`);
+      return { data: { folder, items: data.items || [] }, lines: live.lsLines(folder, data) };
+    },
+  },
+
+  remember: {
+    check(ctx) {
+      const text = ctx.words.join(' ').replace(/\s+/g, ' ').trim();
+      if (!text) throw new UsageError('say what to remember, like atris memory remember "prefers short answers"');
+      if (text.length > REMEMBER_MAX_CHARS) throw new UsageError('keep it to one short line, under 1,000 characters');
+      const file = ctx.flags['--to'] || 'journal';
+      if (!REMEMBER_FILES.includes(file)) throw new UsageError('--to is journal (the default), now or learning');
+      const section = ctx.flags['--section'];
+      if (section && file !== 'learning') throw new UsageError('--section goes with --to learning');
+      if (section && !LEARNING_SECTIONS.includes(section)) throw new UsageError('--section is want, understand or shaky');
+      const body = { text, file, source: (agentName(ctx) || 'terminal').slice(0, 40) };
+      if (section) body.section = section;
+      return body;
+    },
+    async run(ctx, body) {
+      const data = await ctx.call('/me/memory/remember', { method: 'POST', body, retries: 0 });
+      return { data, lines: [`Saved to ${data.file || body.file}: ${String(data.added || body.text).replace(/^- /, '')}`] };
+    },
+  },
+
+  write: {
+    check(ctx) {
+      const [rel, extra] = ctx.words;
+      if (!rel) throw new UsageError('name the page, like wiki/people/sam.md');
+      if (extra !== undefined) {
+        throw new UsageError('the page comes from --file or stdin, not from words. Pipe it in: echo "text" | atris memory write <path>');
+      }
+      return { rel, file: ctx.flags['--file'] };
+    },
+    async run(ctx, { rel, file }) {
+      let buffer;
+      let from = 'the page';
+      if (file && file !== '-') {
+        from = file;
+        try {
+          buffer = fs.readFileSync(path.resolve(ctx.cwd, file));
+        } catch (error) {
+          throw new Error(`could not read ${file}: ${error.code === 'ENOENT' ? 'no such file' : oneLine(error.message)}`);
+        }
+      } else {
+        buffer = await (ctx.deps.readStdin || readStdin)();
+        if (buffer === null) {
+          throw new UsageError(`give the page with --file <file>, or pipe it in: cat page.md | atris memory write ${rel}`);
+        }
+      }
+      if (!buffer.length) {
+        throw new UsageError(`nothing to save, ${from === 'the page' ? 'no text came in' : `${from} is empty`}. To delete a page, run: atris memory rm ${rel}`);
+      }
+      if (buffer.length > MAX_WRITE_BYTES) throw new Error('Keep a write under 1 MB.');
+      let text;
+      try { text = utf8.decode(buffer); } catch { throw new Error(`${from} is not text. Only text pages and files can be saved here.`); }
+      const data = await ctx.call('/memory/write', { method: 'PUT', body: { path: rel, text } });
+      return { data, lines: [`Saved ${data.path || rel} (${live.size(data.bytes != null ? data.bytes : buffer.length)}).`] };
+    },
+  },
+
+  rm: {
+    check(ctx) {
+      return { rel: onePath(ctx, 'page to delete') };
+    },
+    async run(ctx, { rel }) {
+      const data = await ctx.call(`/memory/file?path=${enc(rel)}`, { method: 'DELETE', retries: 0 });
+      return { data, lines: [`Deleted ${data.path || rel} from your Atris memory.`] };
+    },
+  },
+
+  usage: {
+    check(ctx) {
+      if (ctx.words.length) throw new UsageError('usage takes no words');
+    },
+    async run(ctx) {
+      const data = await ctx.call('/memory/usage');
+      return { data, lines: [data.message || `Your files use ${live.size(data.used_bytes)}.`] };
+    },
+  },
+
+  log: {
+    check(ctx) {
+      const agent = needAgent(ctx);
+      const text = ctx.words.join(' ').replace(/\s+/g, ' ').trim();
+      if (!text) throw new UsageError('say what you did, like atris memory log "drafted the lease email" --as codex');
+      return { text, agent };
+    },
+    async run(ctx, body) {
+      const data = await ctx.call('/memory/log', { method: 'POST', body, retries: 0 });
+      return { data, lines: [`Logged in ${data.path}: ${String(data.line || body.text).replace(/^- /, '')}`] };
+    },
+  },
+
+  lesson: {
+    check(ctx) {
+      const agent = needAgent(ctx);
+      const text = ctx.words.join(' ').replace(/\s+/g, ' ').trim();
+      if (!text) throw new UsageError('say the lesson, like atris memory lesson "search names first" --before 3 --after 5 --as codex');
+      const before = numberFlag(ctx, '--before', live.plainNumber);
+      const after = numberFlag(ctx, '--after', live.plainNumber);
+      return { text, score_before: before, score_after: after, agent };
+    },
+    async run(ctx, body) {
+      const data = await ctx.call('/memory/lesson', { method: 'POST', body, retries: 0 });
+      const score = `${body.score_before} -> ${body.score_after}`;
+      const lines = data.kept
+        ? [`Kept in ${data.path}: ${String(data.lesson || body.text).replace(/^- /, '')}`]
+        : [`Not kept, because the score did not go up (${score}). Logged as tried and dropped in ${data.path}.`];
+      return { data, lines };
+    },
+  },
+
+  agents: {
+    local: true,
+    check(ctx) {
+      if (ctx.words.length) throw new UsageError('agents takes no words. To add the rules to a file: --write AGENTS.md');
+    },
+    async run(ctx) {
+      const agent = agentName(ctx);
+      const block = live.rulesBlock(agent);
+      const apiBase = ctx.deps.apiBase || require('../utils/api').getApiBaseUrl();
+      const mcp = live.mcpSetup(apiBase);
+      const target = ctx.flags['--write'];
+      const lines = [];
+      let file = null;
+      if (target) {
+        file = live.writeRulesFile(target, block, ctx.cwd);
+        const shown = path.relative(ctx.cwd, file.path) || file.path;
+        if (file.action === 'added') lines.push(`Added the Atris memory rules to ${shown}.`);
+        else if (file.action === 'replaced') lines.push(`Updated the Atris memory rules in ${shown}. The rest of the file is untouched.`);
+        else lines.push(`${shown} already has these rules. Nothing changed.`);
+      } else {
+        lines.push(
+          'Paste this into the agent\'s rules file (AGENTS.md, CLAUDE.md, .cursorrules or Codex instructions),',
+          'or let atris add it and keep it current: atris memory agents --write AGENTS.md',
+          '',
+          block,
+        );
+      }
+      const setup = live.mcpLines(mcp);
+      if (setup.length) lines.push('', ...setup);
+      return { data: { agent: agent || null, block, file, mcp }, lines };
+    },
+  },
+};
+COMMANDS.setup = COMMANDS.agents;
+
+async function memoryLiveCommand(args = [], deps = {}) {
+  const log = deps.log || console.log;
+  const err = deps.err || console.error;
+  const out = deps.out || ((text) => process.stdout.write(text));
+  const parsed = live.parseLiveArgs(args);
+  const json = Boolean(parsed.json) || args.includes('--json');
+  const sub = parsed.sub || '';
+
+  const usageFail = (message) => {
+    if (json) log(JSON.stringify({ ok: false, error: message }));
+    else err(`atris memory ${sub}: ${message}\n${usageFor(sub)}`);
+    return 2;
+  };
+  const fail = (message, status) => {
+    if (json) log(JSON.stringify({ ok: false, error: message, ...(status ? { status } : {}) }));
+    else err(message);
+    return 1;
+  };
+
+  if (parsed.error) return usageFail(parsed.error);
+  const command = COMMANDS[sub];
+  if (!command) return usageFail('not a memory command');
+  if (parsed.help) {
+    log(usageFor(sub));
+    return 0;
+  }
+
+  const ctx = { ...parsed, deps, env: deps.env || process.env, cwd: deps.cwd || process.cwd() };
+  try {
+    const prepared = command.check ? command.check(ctx) : undefined;
+    if (!command.local) {
+      const auth = await (deps.getAuth || defaultAuth)();
+      if (!auth || !auth.token) return fail(NOT_LOGGED_IN);
+      ctx.call = makeCall(deps, auth);
+    }
+    const result = await command.run(ctx, prepared);
+    if (json) log(JSON.stringify({ ok: true, ...result.data }));
+    else if (result.raw !== undefined) out(result.raw);
+    else for (const line of result.lines) log(line);
+    return 0;
+  } catch (error) {
+    if (error instanceof UsageError) return usageFail(error.message);
+    return fail(oneLine(error && error.message), error && error.status);
+  }
+}
+
+// Called by bin/atris.js before the rest of the CLI loads.
+function runFromCli(args) {
+  const exit = (code) => {
+    if (process.stdout.writableLength === 0) process.exit(code);
+    else process.stdout.write('', () => process.exit(code));
+  };
+  memoryLiveCommand(args)
+    .then((code) => exit(typeof code === 'number' ? code : 0))
+    .catch((error) => {
+      console.error(oneLine(error && error.message ? error.message : error));
+      process.exit(1);
+    });
+}
+
+module.exports = { memoryLiveCommand, plainError, runFromCli };

package/commands/memory.js

@@ -0,0 +1,205 @@
+'use strict';
+
+const os = require('os');
+const path = require('path');
+const { apiRequestJson } = require('../utils/api');
+const { ensureFreshCredentials } = require('../utils/auth');
+const { dangerousWorkspaceReason } = require('../lib/workspace-safety');
+const { NOT_LOGGED_IN, tokenFrom, oneLine } = require('../lib/developer-api');
+const {
+  isRemovable,
+  isWritable,
+  memoryClient,
+  pullFolder,
+  pushFolder,
+  statusFolder,
+} = require('../lib/memory-folder');
+const { progressPrinter } = require('../lib/memory-files');
+const { LIVE_HELP, isLiveCommand } = require('../lib/memory-live');
+
+const USAGE = [
+  ...LIVE_HELP,
+  'copy to laptop: atris memory <pull|push|status> [folder] [--json]',
+  '  pull    copy your Atris memory folder down (default: ~/atris-memory)',
+  '  push    send back changes under wiki/ and files/ (any file under files/: photos, PDFs, recordings)',
+  '          --prune also removes pages under wiki/ and files/ that you deleted here',
+  '  status  show what changed here since the last pull',
+].join('\n');
+
+function resolveDir(arg) {
+  const home = os.homedir();
+  let raw = arg || path.join(home, 'atris-memory');
+  if (raw === '~') raw = home;
+  else if (raw.startsWith('~/')) raw = path.join(home, raw.slice(2));
+  const abs = path.resolve(raw);
+  const reason = dangerousWorkspaceReason(abs);
+  if (reason) throw new Error(`${abs} is ${reason}. Pick a dedicated folder, like ~/atris-memory.`);
+  return abs;
+}
+
+function shortPath(abs) {
+  const home = os.homedir();
+  return abs === home || abs.startsWith(home + path.sep) ? `~${abs.slice(home.length)}` : abs;
+}
+
+function plural(n, one, many) {
+  return `${n} ${n === 1 ? one : many}`;
+}
+
+function nameList(list, max = 4) {
+  const names = list.map((item) => (typeof item === 'string' ? item : item.path));
+  return names.length > max ? `${names.slice(0, max).join(', ')} and ${names.length - max} more` : names.join(', ');
+}
+
+function pullLines(dir, r) {
+  const lines = [`Pulled ${plural(r.total, 'file', 'files')} into ${shortPath(dir)}.`];
+  const parts = [];
+  if (r.added.length) parts.push(`${r.added.length} new`);
+  if (r.updated.length) parts.push(`${r.updated.length} updated`);
+  if (r.same) parts.push(`${r.same} already current`);
+  if (parts.length) lines.push(`${parts.join(', ')}.`);
+  if (r.keptLocal.length) lines.push(`Kept your edits to ${nameList(r.keptLocal)}. The server copy has not changed.`);
+  if (r.conflicts.length) {
+    lines.push(`Left ${nameList(r.conflicts)} alone: it changed here and on the server. To take the server copy, move yours aside and pull again.`);
+  }
+  if (r.unsafe.length) lines.push(`Skipped ${plural(r.unsafe.length, 'file', 'files')} with names that are not safe to copy.`);
+  if (r.gone) lines.push(`${plural(r.gone, 'file is', 'files are')} no longer on the server. Your copies are untouched.`);
+  for (const f of r.failed.slice(0, 3)) lines.push(`Could not copy ${f.path}: ${oneLine(f.error)}`);
+  if (r.failed.length > 3) lines.push(`${r.failed.length - 3} more could not be copied.`);
+  if (r.usedLineFallback) lines.push('The server is on its older download, so line endings may be tidied.');
+  return lines;
+}
+
+function pushLines(r) {
+  const lines = [];
+  if (r.pushed.length) lines.push(`Pushed ${plural(r.pushed.length, 'file', 'files')}: ${nameList(r.pushed)}.`);
+  if (r.alreadyThere.length) lines.push(`Already on the server: ${nameList(r.alreadyThere)}.`);
+  if (r.notPushable.length) {
+    lines.push(`Not pushed: ${nameList(r.notPushable)}. Those change through remember (the Atris connection's remember tool), not by file write.`);
+  }
+  if (r.conflicts.length) {
+    lines.push(`Not pushed: ${nameList(r.conflicts)} changed on the server since your last pull, so nothing was overwritten. Run: atris memory pull`);
+  }
+  if (r.tooBig.length) lines.push(`Not pushed: ${nameList(r.tooBig)} is over 1 MB.`);
+  if (r.notText.length) lines.push(`Not pushed: ${nameList(r.notText)} is not a text file.`);
+  for (const f of r.failed.slice(0, 3)) lines.push(`Could not ${f.removing ? 'remove' : 'push'} ${f.path}: ${oneLine(f.error)}`);
+  lines.push(...deleteLines(r));
+  if (r.skipped.length) lines.push(`Skipped ${nameList(r.skipped.map((s) => `${s.path} (${s.reason})`))}.`);
+  if (!lines.length) lines.push('Nothing to push. Nothing changed since your last pull.');
+  return lines;
+}
+
+const PRUNE_HINT = 'atris memory push --prune';
+
+function deleteLines(r) {
+  const lines = [];
+  if (r.pruned) {
+    if (r.removed.length) lines.push(`Removed ${plural(r.removed.length, 'file', 'files')} from your Atris memory: ${nameList(r.removed)}.`);
+    if (r.alreadyGone.length) lines.push(`Already gone from your Atris memory: ${nameList(r.alreadyGone)}.`);
+    if (r.changedOnServer.length) {
+      lines.push(`Not removed: ${nameList(r.changedOnServer)} changed on the server since your last pull, so nothing was lost. Run: atris memory pull`);
+    }
+    if (r.notRemovable.length) lines.push(`Not removed: ${nameList(r.notRemovable)}. Notes and daily pages can't be deleted; pull brings them back.`);
+    return lines;
+  }
+  const removable = r.deletedHere.filter(isRemovable);
+  const kept = r.deletedHere.filter((rel) => !isRemovable(rel));
+  if (removable.length) {
+    lines.push(`${plural(removable.length, 'file was', 'files were')} deleted here (${nameList(removable)}) and ${removable.length === 1 ? 'is' : 'are'} still in your Atris memory. To remove ${removable.length === 1 ? 'it' : 'them'} there too, run: ${PRUNE_HINT}`);
+  }
+  if (kept.length) lines.push(`${nameList(kept)} ${kept.length === 1 ? 'was' : 'were'} deleted here. Notes and daily pages can't be deleted; pull brings them back.`);
+  return lines;
+}
+
+function pruneNotice(log) {
+  return (doomed) => {
+    log(`Removing ${plural(doomed.length, 'file', 'files')} from your Atris memory, because you deleted ${doomed.length === 1 ? 'it' : 'them'} here:`);
+    for (const rel of doomed) log(`  ${rel}`);
+  };
+}
+
+function statusLines(r) {
+  const rows = [
+    ...r.modified.map((rel) => ['edited', rel]),
+    ...r.added.map((rel) => ['new', rel]),
+    ...r.deleted.map((rel) => ['deleted', rel]),
+  ];
+  const when = r.pulledAt ? ` (last pull ${r.pulledAt})` : '';
+  if (!rows.length) return [`Nothing changed here since your last pull${when}.`];
+  const lines = [`Changed here since your last pull${when}:`];
+  for (const [kind, rel] of rows) {
+    const note = kind === 'deleted'
+      ? (isRemovable(rel) ? `  (${PRUNE_HINT} removes it from Atris)` : '  (notes and daily pages stay; pull brings it back)')
+      : isWritable(rel) ? '' : '  (changes through remember, not pushed)';
+    lines.push(`  ${kind.padEnd(8)} ${rel}${note}`);
+  }
+  for (const s of r.skipped) lines.push(`  skipped  ${s.path} (${s.reason})`);
+  return lines;
+}
+
+async function defaultToken() {
+  const creds = await ensureFreshCredentials(apiRequestJson);
+  return { token: tokenFrom(creds), account: (creds && creds.user_id) || null };
+}
+
+async function memoryCommand(args = [], deps = {}) {
+  const log = deps.log || console.log;
+  const err = deps.err || console.error;
+  const json = args.includes('--json');
+  const prune = args.includes('--prune');
+  const words = args.filter((arg) => !arg.startsWith('-'));
+  const [sub, folderArg] = words;
+  if (isLiveCommand(sub)) return require('./memory-live').memoryLiveCommand(args, deps);
+  const help = args.includes('--help') || args.includes('-h') || sub === 'help' || !sub;
+  if (help) {
+    log(USAGE);
+    return 0;
+  }
+  if (!['pull', 'push', 'status'].includes(sub)) {
+    err(`atris memory: unknown command "${sub}"\n${USAGE}`);
+    return 2;
+  }
+  if (prune && sub !== 'push') {
+    err(`atris memory: --prune only works with push\n${USAGE}`);
+    return 2;
+  }
+
+  const fail = (message) => {
+    if (json) log(JSON.stringify({ ok: false, error: oneLine(message) }));
+    else err(oneLine(message));
+    return 1;
+  };
+
+  try {
+    const dir = resolveDir(folderArg);
+    let result;
+    let lines;
+    let code = 0;
+    if (sub === 'status') {
+      result = statusFolder({ dir });
+      lines = statusLines(result);
+    } else {
+      const { token, account } = await (deps.getToken || defaultToken)();
+      if (!token) return fail(NOT_LOGGED_IN);
+      const client = memoryClient(deps.apiRequestJson || apiRequestJson, token);
+      const tty = deps.tty !== undefined ? deps.tty : (process.stderr.isTTY ? process.stderr : null);
+      const onProgress = json ? null : progressPrinter({ log, tty });
+      if (sub === 'pull') {
+        result = await pullFolder({ dir, client, account, onProgress });
+        lines = pullLines(dir, result);
+        code = result.failed.length ? 1 : 0;
+      } else {
+        result = await pushFolder({ dir, client, account, prune, onPrune: json ? null : pruneNotice(log), onProgress });
+        lines = pushLines(result);
+        code = result.failed.length || result.conflicts.length || (result.changedOnServer || []).length ? 1 : 0;
+      }
+    }
+    if (json) log(JSON.stringify({ ok: code === 0, dir, ...result }));
+    else for (const line of lines) log(line);
+    return code;
+  } catch (error) {
+    return fail(error && error.message);
+  }
+}
+
+module.exports = { memoryCommand };

package/lib/auto-accept-certified.js

@@ -715,12 +715,12 @@ function runVerifyCommandCached(verify, workspaceRoot, cache = null) {
 // root: one scan covers every task in a sweep.
 const repoHygieneCache = new Map();
 
-function repoHygieneGate(workspaceRoot) {
+function repoHygieneGate(workspaceRoot, skillScope = null) {
   const root = path.resolve(workspaceRoot || process.cwd());
   // Skill receipts are mutable workspace state, so recompute this gate before
   // consulting the repo-wide dead-code cache. A new receipt can unblock a
   // landing, while a later SKILL.md edit must make an older receipt stale.
-  const skillEval = skillEvalGate(root);
+  const skillEval = skillEvalGate(root, skillScope || {});
   if (!skillEval.ok) return skillEval;
   if (repoHygieneCache.has(root)) return repoHygieneCache.get(root);
   let result = { ok: true, skipped: true };
@@ -755,8 +755,17 @@ function repoHygieneGate(workspaceRoot) {
 
 // Shared by both landing lanes so the check cannot ship in one dispatch branch
 // and silently skip the sibling (lesson: parallel-paths-drift).
-function hygieneBlockResult(task, ref) {
-  const hygiene = repoHygieneGate(task.workspace_root || process.cwd());
+// A job answers for the skills it changed. When its exact file list is on
+// record (the same list the taste check just read), only those files count,
+// read where the job's branch is checked out. With no list on record the
+// workspace-wide check stays, so an unevaluated skill is never waved through.
+function jobSkillScope(task, candidateGate) {
+  if (!candidateGate || candidateGate.advisory_only || !Array.isArray(candidateGate.paths)) return null;
+  return { changeRoot: candidateWorkspaceRoot(task), paths: candidateGate.paths };
+}
+
+function hygieneBlockResult(task, ref, candidateGate = null) {
+  const hygiene = repoHygieneGate(task.workspace_root || process.cwd(), jobSkillScope(task, candidateGate));
   if (hygiene.ok) return null;
   return {
     eligible: false,
@@ -1360,7 +1369,7 @@ function evaluateAutoAccept(task, options = {}) {
     if (executeVerify) {
       candidateGate = candidatePolicyGate(task, { verifyCache, executeDetectors: true });
       if (!candidateGate.ok) return { ...candidateGate, ref };
-      const hygieneBlock = hygieneBlockResult(task, ref);
+      const hygieneBlock = hygieneBlockResult(task, ref, candidateGate.gate);
       if (hygieneBlock) return hygieneBlock;
     }
     return {
@@ -1444,7 +1453,7 @@ function evaluateAutoAccept(task, options = {}) {
   if (executeVerify) {
     candidateGate = candidatePolicyGate(task, { verifyCache, executeDetectors: true });
     if (!candidateGate.ok) return { ...candidateGate, ref };
-    const hygieneBlock = hygieneBlockResult(task, ref);
+    const hygieneBlock = hygieneBlockResult(task, ref, candidateGate.gate);
     if (hygieneBlock) return hygieneBlock;
   }
 

package/lib/known-commands.js

@@ -3,8 +3,8 @@
 const knownCommands = ['init', 'guide', 'doctor', 'doc-health', 'install', 'workspace', 'log', 'logs', 'later', 'idea', 'done', 'wish', 'ask', 'approve', 'stop', 'ready', 'check', 'drill', 'dream', 'now', '99', 'goal', 'wtf', 'founder', 'orb', 'radar', 'who', 'stream', 'ctop', 'launchpad', 'status', 'analytics', 'revisions', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', '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', 'recover', 'search', 'scout', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'taste', 'teach', 'plugin', 'experiments', 'bench', 'router', 'tree', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'watch', 'cloud', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube', 'x-search',
-                       'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'decide', 'campaign', 'agents', 'probe', 'worktree', 'land', 'caretaker', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'sentinel', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'scoreboard', 'scorecard', 'rating', 'sync-checkout', 'zen',
-                       'ci', 'github', 'vercel', 'supabase', 'linear', 'stripe', 'balance', 'usage', 'spend', 'api-key', 'agent-client', 'topup', 'buy', 'transactions', 'hire', 'hires', 'mail', 'design', 'mcp', 'gmail', 'google', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
+                       'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'decide', 'campaign', 'agents', 'probe', 'worktree', 'land', 'caretaker', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'sentinel', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'scoreboard', 'growth', 'scorecard', 'rating', 'sync-checkout', 'zen',
+                       'ci', 'github', 'vercel', 'supabase', 'linear', 'stripe', 'memory', 'balance', 'usage', 'spend', 'api-key', 'agent-client', 'topup', 'buy', 'transactions', 'hire', 'hires', 'mail', 'design', 'mcp', 'gmail', 'google', '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', 'link', 'playbook', 'feed', 'brief', 'social', 'host', 'people', 'follow', 'unfollow', 'friends', 'msg', 'inbox', 'invite', 'join', 'rsi', 'pay', 'trust'];
 
 // Damerau-Levenshtein edit distance between two short strings. Counts an