atris 3.82.26 → 3.83.0

package/lib/cleanup-summary.js

@@ -76,9 +76,11 @@ function parkedBranchCount(root) {
 
 function shorten(text, max) {
   if (text.length <= max) return text;
-  const cut = text.slice(0, max - 1);
+  const cut = text.slice(0, Math.max(0, max - 3));
   const stop = Math.max(cut.lastIndexOf('; '), cut.lastIndexOf(', '));
-  return `${(stop > max * 0.5 ? cut.slice(0, stop) : cut).replace(/[\s,;.]+$/, '')}...`;
+  const wordEnd = /\s/.test(text[cut.length] || '') ? cut.length : cut.lastIndexOf(' ');
+  const end = stop > max * 0.5 ? stop : Math.max(0, wordEnd);
+  return `${cut.slice(0, end).replace(/[\s,;.]+$/, '')}...`;
 }
 
 // The newest cleanup line from today's journal (yesterday's if today has

package/lib/first-minute.js

@@ -133,11 +133,31 @@ function hasLiveWork({
   return Boolean(task || backlogCount > 0 || wipCount > 0 || inboxCount > 0);
 }
 
-function softTitle(title, maxWords = 5) {
-  const words = String(title || '').replace(/\s+/g, ' ').trim().split(' ').filter(Boolean);
-  if (!words.length) return '';
-  const text = words.slice(0, maxWords).join(' ').replace(/[.,;:!?]+$/g, '');
-  return `"${text.toLowerCase()}"`;
+// The first task every new folder gets is written for agents ("Generate
+// MAP.md, scan codebase, ..."). A person sees what it means instead.
+function plainTitle(title) {
+  const text = String(title || '');
+  return /^\s*generate map\.md\b/i.test(text) ? 'map this folder so agents can find things' : text;
+}
+
+function softTitle(title) {
+  const text = plainTitle(title).replace(/\s+/g, ' ').trim();
+  if (!text) return '';
+  let shortened = text;
+  if (text.length > 60) {
+    const part = text.slice(0, 57);
+    const boundary = part.lastIndexOf(' ');
+    shortened = `${(boundary > 0 ? part.slice(0, boundary) : part).replace(/[.,;:!?]+$/g, '')}...`;
+  } else {
+    shortened = text.replace(/[.,;:!?]+$/g, '');
+  }
+  return `"${shortened.toLowerCase()}"`;
+}
+
+// The greeting is two lines: what is already here, then one command. The
+// command sits alone on its line so it can be copied and pasted as is.
+function nextLine(command) {
+  return `next: ${command}`;
 }
 
 function taskRef(task) {
@@ -723,7 +743,7 @@ function renderLaterRemember({ person = '', sentence = '', files, root, later }
   return [
     `${greet(person)}I'll remember ${remembered}.`,
     '',
-    `next: ${freshNextCommand(files, 'this folder', { root, later: remembered })}`,
+    nextLine(freshNextCommand(files, 'this folder', { root, later: remembered })),
   ].join('\n');
 }
 
@@ -733,7 +753,7 @@ function renderFresh({ person = '', folder = 'this folder', files, root, commit,
   return [
     `${greet(person)}${freshWinLine({ folder: room, files, root, commit, dirty, branch, later })}`,
     '',
-    `next: ${freshNextCommand(files, room, extra)}`,
+    nextLine(freshNextCommand(files, room, extra)),
   ].join('\n');
 }
 
@@ -803,7 +823,7 @@ function renderFirstTalk({ person = '', folder = 'this folder', starter = null,
   return [
     `${greet(person)}${title} is started. nothing is built yet.`,
     '',
-    `next: ${build || firstTalkNext({ starter, person, folder: room })}`,
+    nextLine(build || firstTalkNext({ starter, person, folder: room })),
   ].join('\n');
 }
 
@@ -829,7 +849,7 @@ function renderStarterNewWork({ person = '', task = null, files = [], folder = '
   return [
     `${greet(person)}${starterTitle(task, folder)} has new work: ${spokenBuiltList(files)}.`,
     '',
-    'next: atris done',
+    nextLine('atris done'),
   ].join('\n');
 }
 
@@ -842,9 +862,9 @@ function shippedHumanStarter(tasks) {
 
 function renderStarterShipped({ person = '', task = null, folder = 'this folder' } = {}) {
   return [
-    `${greet(person)}you already shipped ${starterTitle(task, folder)}.`,
+    `${greet(person)}you already finished ${starterTitle(task, folder)}.`,
     '',
-    `next: ${WHATS_NEXT_COMMAND}`,
+    nextLine(WHATS_NEXT_COMMAND),
   ].join('\n');
 }
 
@@ -852,7 +872,7 @@ function renderWhatsNextAsk({ person = '', task = null, folder = 'this folder' }
   return [
     `${greet(person)}${starterTitle(task, folder)} is shipped. say the next thing you want here, in your own words.`,
     '',
-    'next: atris "<the next thing you want>"',
+    nextLine('atris "<the next thing you want>"'),
   ].join('\n');
 }
 
@@ -886,26 +906,26 @@ function renderWorkspace({
   const title = task && softTitle(task.title);
   let win = `${who}${folder || 'this folder'} is set up.`;
   if (task && task.status === 'done' && title) {
-    win = `${who}you already shipped ${title}.`;
+    win = `${who}you already finished ${title}.`;
   } else if (task && task.status === 'review') {
-    win = `${who}something finished. waiting on you.`;
+    win = `${who}${title || 'this work'} is waiting for your ok.`;
   } else if (task && task.status === 'claimed' && title) {
-    win = `${who}${title} is already yours.`;
+    win = `${who}you are working on ${title}.`;
   } else if (task && task.status === 'open' && title) {
-    win = `${who}${title} is ready to claim.`;
+    win = `${who}${title} is ready to start.`;
   } else if (movingTitle && liveWork) {
     win = `${who}${softTitle(movingTitle)} is waiting.`;
   } else if (completedTitle && !liveWork) {
-    win = `${who}you already shipped ${softTitle(completedTitle)}.`;
+    win = `${who}you already finished ${softTitle(completedTitle)}.`;
   } else if (recap && recap.title && !liveWork) {
     win = `${who}you already have a recap in ${folder || 'this folder'}: ${recap.title}.`;
   } else if (liveWork) {
-    win = `${who}${folder || 'this folder'} has work in motion.`;
+    win = `${who}${folder || 'this folder'} has work in progress.`;
   }
   const lines = [win];
   if (recap && recap.title && task) lines.push(`last recap: ${recap.title}.`);
   lines.push('');
-  lines.push(`next: ${nextCommand}`);
+  lines.push(nextLine(nextCommand));
   return lines.join('\n');
 }
 
@@ -1138,7 +1158,7 @@ function speakNothingRunning({
     return 2;
   }
   log('');
-  log(`${greet(personName())}nothing is running.\n\nnext: ${next}`);
+  log(`${greet(personName())}nothing is running.\n\n${nextLine(next)}`);
   return 0;
 }
 
@@ -1186,6 +1206,7 @@ function speakKeepWorkingMinute({
 }
 
 module.exports = {
+  plainTitle,
   buildFirstMinute,
   deskNextCommand,
   firstTalkCommand,

package/lib/gm-phone-page.js

@@ -448,15 +448,21 @@ body.waiting .bet { position: absolute; left: 24px; right: 24px; width: auto; to
       if (w.text === node.textContent && w.bad === node.classList.contains('bad')) return;
       busy = true;
       fading = true;
+      var ns = getComputedStyle(node), seen = Boolean(node.textContent) && ns.display !== 'none' && Number(ns.opacity) > 0;
       node.classList.add('out');
-      setTimeout(function () {
+      var swap = function () {
         node.textContent = w.text;
         node.classList.toggle('bad', w.bad);
         node.classList.remove('out');
         fading = false;
         // each line stays long enough to read before the next one
         setTimeout(function () { busy = false; next(); }, 650);
-      }, reduced ? 200 : 280);
+      };
+      // the words change once their fade has run all the way. A timer alone
+      // emptied them a frame or two early, as the fade starts a frame late, and
+      // on a machine drawing without a gpu they vanished at 0.17. With no
+      // words in sight there is no fade to wait out, so the timer stays.
+      if (seen) afterFade(node, reduced ? 200 : 280, swap); else setTimeout(swap, reduced ? 200 : 280);
     }
     return {
       set: function (text, bad) { want = { text: text, bad: Boolean(bad) }; next(); },

package/lib/known-commands.js

@@ -5,7 +5,7 @@ const knownCommands = ['init', 'guide', 'doctor', 'doc-health', 'install', 'work
                        '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', 'growth', 'scorecard', 'rating', 'sync-checkout', 'zen',
                        'ci', 'github', 'vercel', 'supabase', 'linear', 'stripe', 'memory', 'balance', 'film', 'usage', 'spend', 'api-key', 'agent-client', 'topup', 'buy', 'transactions', 'hire', 'hires', 'mail', 'channel', 'listen', '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'];
+                       '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', 'night', 'morning', 'rsi', 'pay', 'trust'];
 
 // Damerau-Levenshtein edit distance between two short strings. Counts an
 // adjacent transposition (e.g. "taks" -> "task") as a single edit, since

package/lib/member-export.js

@@ -8,6 +8,10 @@
 //   codex   .codex/agents/<name>.toml  agent role file (name, description, developer_instructions);
 //                                      codex 0.162 discovers roles in .codex/agents
 //
+// Each file carries the whole identity: MEMBER.md's body, then SOUL.md,
+// MISSION.md and goals.md when the member has them, so an outside engine
+// loads who the member is and what it is for, not only its rules.
+//
 // Every file carries GENERATED_MARK. Export only overwrites or removes files
 // that carry it, so a hand-written agent with the same name is left alone.
 // Parked members are skipped, and their old generated files are removed.
@@ -68,6 +72,28 @@ function memberSkills(dir, fields) {
   return [...names].sort();
 }
 
+// The body of an identity file next to MEMBER.md, frontmatter and HTML
+// comments removed, or '' when the member has none.
+function identityText(dir, file, text) {
+  if (text === undefined) {
+    try {
+      text = fs.readFileSync(path.join(dir, file), 'utf8');
+    } catch {
+      return '';
+    }
+  }
+  if (text === null) return '';
+  return frontmatterOf(text).body.replace(/<!--[\s\S]*?-->/g, '').replace(/\n{3,}/g, '\n\n').trim();
+}
+
+// The files that say who a member is beyond MEMBER.md, in the order an
+// engine should read them.
+const IDENTITY_FILES = [
+  ['soul', 'SOUL.md', 'Soul'],
+  ['mission', 'MISSION.md', 'Mission'],
+  ['goals', 'goals.md', 'Goals'],
+];
+
 function readMembers(root) {
   const teamDir = path.join(root, 'atris', 'team');
   let entries = [];
@@ -100,6 +126,7 @@ function readMembers(root) {
       model: scalar(fields.model),
       skills: memberSkills(dir, fields),
       body: body.trim(),
+      ...Object.fromEntries(IDENTITY_FILES.map(([key, file]) => [key, identityText(dir, file)])),
     });
   }
   return { members, parked };
@@ -126,6 +153,9 @@ function instructions(member) {
     '',
   ];
   if (member.body) lines.push(member.body, '');
+  for (const [key, file, title] of IDENTITY_FILES) {
+    if (member[key]) lines.push(`## ${title} (atris/team/${member.slug}/${file})`, '', member[key], '');
+  }
   if (member.skills.length) {
     lines.push('## Skills', '');
     for (const skill of member.skills) {
@@ -233,6 +263,7 @@ function summaryLine(result, { dryRun = false } = {}) {
 
 module.exports = {
   GENERATED_MARK,
+  identityText,
   agentName,
   exportMembers,
   frontmatterOf,

package/lib/memory-folder.js

@@ -11,13 +11,16 @@ const crypto = require('crypto');
 const transfer = require('./memory-files');
 
 const STATE_FILE = '.atris-memory.json';
-const WRITABLE_PREFIXES = ['wiki/', 'files/'];
+const WRITABLE_PREFIXES = ['wiki/', 'files/', 'features/'];
 const MAX_WRITE_BYTES = 1000000;
 const READ_PAGE = 400;
 const FETCH_PARALLEL = 6;
 const MAX_FOLDERS = 2000;
 const MAX_LOCAL_FILES = 20000;
 const MAX_DEPTH = 24;
+const MAX_BUNDLE_HAVE = 5000;
+// Twice the maximum folder size, even if every answer advances by just one file.
+const MAX_BUNDLE_ANSWERS = 10000;
 
 const utf8 = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
 
@@ -189,6 +192,7 @@ function memoryClient(request, token) {
     rawFileMissing: false,
     filesSupported: null, // false once the server shows it has no file links yet
     sizes: new Map(), // bytes of each file, from the listing
+    etags: new Map(),
 
     async list() {
       const found = [];
@@ -207,7 +211,7 @@ function memoryClient(request, token) {
           for (const item of items) {
             const name = String(item.name || '');
             const full = folder ? `${folder}/${name}` : name;
-            if (!name.endsWith('/')) { found.push(full); client.sizes.set(full, Number(item.size)); }
+            if (!name.endsWith('/')) { found.push(full); client.sizes.set(full, Number(item.size)); if (item.etag) client.etags.set(full, item.etag); }
             else if (cleanRel(full.slice(0, -1))) level.push(full.slice(0, -1));
             else found.push(full); // never descended; pull counts it as an unsafe name
           }
@@ -216,12 +220,24 @@ function memoryClient(request, token) {
       return found.sort();
     },
 
+    async bundle(have, after) {
+      const result = await call('/memory/bundle', { method: 'POST', body: { have, after } });
+      if (result.status === 404 || result.status === 405) return null;
+      if (!result.ok) throw apiError(result, 'could not download the folder');
+      const data = result.data;
+      if (!data || !Array.isArray(data.pages) || !Array.isArray(data.gone) || !Array.isArray(data.skipped)
+        || (data.next != null && (typeof data.next !== 'string' || !data.next))) {
+        throw new Error('could not download the folder: invalid bundle response');
+      }
+      return data;
+    },
+
     // { exists: false } when the server has no such file; throws on any other trouble.
     async read(rel) {
       if (!client.rawFileMissing) {
         const result = await call(`/memory/file?path=${query(rel)}`);
         if (result.ok && result.data && typeof result.data.text === 'string') {
-          return { exists: true, text: result.data.text };
+          return { exists: true, text: result.data.text, etag: result.data.etag || client.etags.get(rel) };
         }
         if (result.status === 404) client.rawFileMissing = true;
         else if (/^No file at/.test(String(result.error || ''))) return { exists: false };
@@ -302,7 +318,7 @@ function noFiles(client) {
 // "changed": it changed since the last pull, so it is never overwritten.
 // Files fetched as files are compared by S3 fingerprint, pages by their text.
 async function serverCheck(client, rel, base, local, { asFile = false } = {}) {
-  if ((asFile || (base && base.etag)) && client.filesSupported !== false) {
+  if ((asFile || (base && base.etag && !base.page)) && client.filesSupported !== false) {
     const info = await client.link(rel);
     if (!info.exists) return { verdict: 'clear', exists: false };
     if (local && info.md5 && info.md5 === local.md5 && info.bytes === local.bytes) {
@@ -430,17 +446,15 @@ async function pullFolder({ dir, client, account = null, now = () => new Date(),
   const rootReal = fs.realpathSync(dir);
   const state = loadState(rootReal) || { version: 1, files: {} };
   checkAccount(state, account);
+  const originalState = JSON.stringify(state);
   if (account) state.account = account;
+  const out = { total: 0, added: [], updated: [], same: 0, keptLocal: [], conflicts: [], failed: [], unsafe: [], gone: 0 };
+  const movedAsFile = (rel) => Boolean(state.files[rel] && state.files[rel].etag && !state.files[rel].page);
 
-  const remote = await client.list();
-  const out = { total: remote.length, added: [], updated: [], same: 0, keptLocal: [], conflicts: [], failed: [], unsafe: [], gone: 0 };
-  const movedAsFile = (rel) => Boolean(state.files[rel] && state.files[rel].etag);
-  const asFiles = remote.filter((rel) => cleanRel(rel) && (transfer.goesAsFile(rel, client.sizes.get(rel)) || movedAsFile(rel)));
-
-  const pullText = async (rel) => {
+  const pullText = async (rel, bundled = null) => {
     if (!cleanRel(rel)) { out.unsafe.push(rel); return; }
     let file;
-    try { file = await client.read(rel); } catch (error) {
+    try { file = bundled || await client.read(rel); } catch (error) {
       // A .csv or .txt that is not UTF-8, sent from another laptop as a file: fetch it as one.
       if (rel.startsWith('files/') && client.filesSupported !== false
         && await pullFile({ rootReal, rel, client, state, out, onProgress })) return;
@@ -457,6 +471,7 @@ async function pullFolder({ dir, client, account = null, now = () => new Date(),
       try { localSha = transfer.hashFileSync(abs).sha256; } catch { /* no local copy */ }
       const { md5 } = transfer.printOf(Buffer.from(file.text, 'utf8'));
       const record = { sha256: remoteSha, bytes: Buffer.byteLength(file.text, 'utf8'), md5 };
+      if (file.etag) { record.etag = file.etag; record.page = true; }
       if (localSha === remoteSha) {
         out.same += 1;
         state.files[rel] = record;
@@ -469,6 +484,7 @@ async function pullFolder({ dir, client, account = null, now = () => new Date(),
         state.files[rel] = record;
         out.updated.push(rel);
       } else if (base && remoteSha === base) {
+        state.files[rel] = record;
         out.keptLocal.push(rel);
       } else {
         out.conflicts.push(rel);
@@ -477,26 +493,108 @@ async function pullFolder({ dir, client, account = null, now = () => new Date(),
       out.failed.push({ path: rel, error: error.message });
     }
   };
-  const fileSet = new Set(asFiles);
-  await mapLimit(remote.filter((rel) => !fileSet.has(rel)), FETCH_PARALLEL, pullText);
-  await moveFiles(asFiles, (rel) => client.sizes.get(rel) || 0, async (rel) => {
-    const done = client.filesSupported !== false && await pullFile({ rootReal, rel, client, state, out, onProgress });
-    if (!done) await pullText(rel); // an older server: copy it as text, as before
-  });
-
-  const onServer = new Set(remote);
-  for (const rel of Object.keys(state.files)) {
-    if (!onServer.has(rel)) { delete state.files[rel]; out.gone += 1; }
+  // Only advertise copies that still exist locally, so a deleted local file is restored.
+  const have = {};
+  let haveCount = 0;
+  for (const [rel, base] of Object.entries(state.files)) {
+    if (haveCount >= MAX_BUNDLE_HAVE) break;
+    if (!cleanRel(rel) || !base.etag) continue;
+    try {
+      const abs = localTarget(rootReal, rel);
+      if (fs.existsSync(abs)) { have[rel] = base.etag; haveCount += 1; }
+    } catch { /* a path that cannot be copied must not be advertised */ }
+  }
+  let bundle = await client.bundle(have, '');
+  if (bundle) {
+    const changed = new Set();
+    const gone = new Set();
+    const skipped = new Map();
+    let after = '';
+    let answers = 0;
+    try {
+      do {
+        answers += 1;
+        for (const page of bundle.pages) {
+          if (!page || typeof page.path !== 'string' || typeof page.text !== 'string' || typeof page.etag !== 'string') {
+            throw new Error('could not download the folder: invalid bundle page');
+          }
+          changed.add(page.path);
+          await pullText(page.path, { exists: true, text: page.text, etag: page.etag });
+        }
+        for (const rel of bundle.gone) gone.add(rel);
+        for (const item of bundle.skipped) {
+          if (!item || typeof item.path !== 'string') throw new Error('could not download the folder: invalid skipped file');
+          skipped.set(item.path, item);
+        }
+        if (!bundle.next) break;
+        // Compare Unicode code points, matching the server's path ordering.
+        const previous = Array.from(after, (char) => char.codePointAt(0));
+        const next = Array.from(bundle.next, (char) => char.codePointAt(0));
+        const firstDifference = next.findIndex((value, index) => index >= previous.length || value !== previous[index]);
+        if (firstDifference < 0 || (firstDifference < previous.length && next[firstDifference] < previous[firstDifference])) {
+          throw new Error('could not download the folder: bundle cursor did not move forward');
+        }
+        if (answers >= MAX_BUNDLE_ANSWERS) throw new Error('could not download the folder: too many bundle answers');
+        after = bundle.next;
+        bundle = await client.bundle(have, after);
+        if (!bundle) throw new Error('could not download the folder: bundle stopped during download');
+      } while (true);
+    } catch (error) {
+      // Save completed pages, but never apply removals from an unfinished pass.
+      if (JSON.stringify(state) !== originalState) saveState(rootReal, state);
+      throw error;
+    }
+    for (const [rel, item] of skipped) {
+      if (!cleanRel(rel)) { out.unsafe.push(rel); continue; }
+      const done = client.filesSupported !== false && await pullFile({ rootReal, rel, client, state, out, onProgress });
+      if (!done) await pullText(rel);
+    }
+    for (const rel of Object.keys(have)) {
+      if (changed.has(rel) || gone.has(rel) || skipped.has(rel)) continue;
+      try {
+        const local = transfer.hashFileSync(localTarget(rootReal, rel));
+        if (local.sha256 === state.files[rel].sha256) out.same += 1;
+        else out.keptLocal.push(rel);
+      } catch (error) { out.failed.push({ path: rel, error: error.message }); }
+    }
+    for (const rel of gone) {
+      if (Object.hasOwn(state.files, rel)) { delete state.files[rel]; out.gone += 1; }
+    }
+    out.total = changed.size + skipped.size + Object.keys(have).filter((rel) => !changed.has(rel) && !gone.has(rel) && !skipped.has(rel)).length;
+  } else {
+    const remote = await client.list();
+    out.total = remote.length;
+    const asFiles = remote.filter((rel) => cleanRel(rel) && (transfer.goesAsFile(rel, client.sizes.get(rel)) || movedAsFile(rel)));
+    const fileSet = new Set(asFiles);
+    await mapLimit(remote.filter((rel) => !fileSet.has(rel)), FETCH_PARALLEL, async (rel) => {
+      const base = state.files[rel];
+      if (base && base.etag && client.etags.get(rel) === base.etag && have[rel]) {
+        try {
+          const local = transfer.hashFileSync(localTarget(rootReal, rel));
+          if (local.sha256 === base.sha256) out.same += 1; else out.keptLocal.push(rel);
+        } catch (error) { out.failed.push({ path: rel, error: error.message }); }
+      } else await pullText(rel);
+    });
+    await moveFiles(asFiles, (rel) => client.sizes.get(rel) || 0, async (rel) => {
+      const done = client.filesSupported !== false && await pullFile({ rootReal, rel, client, state, out, onProgress });
+      if (!done) await pullText(rel);
+    });
+    const onServer = new Set(remote);
+    for (const rel of Object.keys(state.files)) {
+      if (!onServer.has(rel)) { delete state.files[rel]; out.gone += 1; }
+    }
+  }
+  if (JSON.stringify(state) !== originalState || !fs.existsSync(path.join(rootReal, STATE_FILE))) {
+    state.pulled_at = now().toISOString();
+    saveState(rootReal, state);
   }
-  state.pulled_at = now().toISOString();
-  saveState(rootReal, state);
   for (const key of ['added', 'updated', 'keptLocal', 'conflicts', 'unsafe']) out[key].sort();
   out.usedLineFallback = client.usedLineFallback;
   return out;
 }
 
 // Remove from the server the pages deleted here since the last pull. Only
-// wiki/ and files/, and only while the server copy is still the one pulled, so
+// wiki/, files/ and features/, and only while the server copy is still the one pulled, so
 // a page someone changed elsewhere is never lost. onPrune hears the list first.
 async function pruneDeleted({ state, client, deleted, out, onPrune }) {
   const doomed = deleted.filter(isRemovable).sort();

package/lib/memory-live.js

@@ -28,8 +28,8 @@ const USAGE_LINES = {
   ls: row('ls [folder]', 'what is in a folder; MAP.md says what is where'),
   remember: row('remember "one short line"', 'a lasting fact or preference about the person, when they',
     'say remember, note, save or don\'t forget [--to now|learning]'),
-  write: row('write <path> [--file f]', 'save a page under wiki/ or a file under files/, or pipe it in'),
-  rm: row('rm <path>', 'delete a page under wiki/ or a file under files/'),
+  write: row('write <path> [--file f]', 'save a page under wiki/ or features/, or a file under files/, or pipe it in'),
+  rm: row('rm <path>', 'delete a page under wiki/ or features/, or a file under files/'),
   usage: row('usage', 'file space used and what the plan gives'),
   log: row('log "what I did" --as <agent>', 'one line in your notebook, team/<agent>/logs/<today>'),
   lesson: row('lesson "text" --before N --after N', 'kept in team/<agent>/lessons.md only when the score', 'went up (--as <agent>)'),