synabun 2.0.5 → 2.0.9

package/hooks/claude-code/session-start.mjs

@@ -33,7 +33,7 @@ import { execSync } from 'node:child_process';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
-import { getHookFeatures, detectProject, ensureProjectCategories, cleanupStaleLoops, cleanupStalePendingRemember, cleanupStaleFiles, appendCapped, DATA_DIR, isTemporaryChat, niUrl, greetingSurface, greetingOff, GREETING_NOTE_DIR } from './shared.mjs';
+import { getHookFeatures, detectProject, cleanupStaleLoops, cleanupStalePendingRemember, cleanupStaleFiles, appendCapped, DATA_DIR, isTemporaryChat, niUrl, greetingSurface, greetingOff, GREETING_NOTE_DIR } from './shared.mjs';
 
 // CC updates (especially when installer runs as root) can wipe ~/.claude.json
 // or strip mcpServers.SynaBun, leaving the side panel/CLI with MCP disabled
@@ -228,9 +228,6 @@ async function main() {
     } catch { /* ok */ }
   }
 
-  // Ensure all registered projects have their default category trees
-  try { withStateLock(() => ensureProjectCategories()); } catch { /* non-critical */ }
-
   // Self-heal SynaBun MCP registration (CC updates can strip it)
   healSynaBunMcp();
 

package/hooks/claude-code/shared.mjs

@@ -1031,15 +1031,21 @@ export function buildCategoryTree(categories) {
 }
 
 // --- Auto-category creation ---
+// A fresh install has no categories. The only ones made without being asked are a
+// project's defaults (when the project is added) and a feature's own category (the
+// first time that feature saves into it).
 
 /**
- * Standalone categories required by hooks. Always created regardless of projects.
+ * Categories features save into by name, created on first save, never earlier.
+ * The hooks' and the Neural Interface's share of mcp-server/src/services/categories.ts
+ * FEATURE_CATEGORIES: keep the descriptions the same.
  */
-const STANDALONE_DEFAULTS = [
-  { name: 'conversations', description: 'Session summaries and conversation indexing' },
-  { name: 'communication-style', description: 'User communication patterns and preferences' },
-  { name: 'plans', description: 'Implementation plans stored after plan mode approval', is_parent: true, color: '#06d6a0' },
-];
+export const FEATURE_CATEGORIES = {
+  conversations: { description: 'Indexed conversation sessions with compacted summaries for cross-session recall: session metadata (date, branch, session id) and topic summaries, so past conversations can be found by asking for them.' },
+  'communication-style': { description: 'How the user communicates and works: patterns in how they give instructions, correct, decide and signal frustration, and their stated preferences.' },
+  plans: { description: 'Implementation plans stored after plan mode approval, one child category per project.', is_parent: true },
+  uncategorized: { description: 'Fallback for memories stored without a category.' },
+};
 
 /**
  * Default child categories for every registered project.
@@ -1052,90 +1058,118 @@ const PROJECT_CHILDREN = [
   { suffix: 'config', description: 'Configuration, deployment, environment, and infrastructure' },
 ];
 
+/** A project's parent category name: the label normalized, cut to 16 so children stay within 30 chars (16 + 1 + 12 = 29). */
+export function projectCategoryLabel(label) {
+  let name = normalizeLabel(String(label || ''));
+  if (name.length > 16) name = name.slice(0, 16).replace(/-$/, '');
+  return name;
+}
+
 /**
- * Ensure all registered projects have a parent category with default children,
- * and that standalone hook-required categories exist.
+ * Add the categories in `defs` that are missing, in order (parents first), to the
+ * MCP server's categories file (no connection suffix), whose watcher refreshes the
+ * tool schemas. A missing file is an empty list; an unreadable one is left alone.
+ * `mutate(categories, now)` may push more entries and return the names it created.
  *
- * Writes to the MCP server's categories file (no connection suffix) so the
- * MCP server's file watcher picks up changes and refreshes tool schemas.
- *
- * Idempotent: only adds missing categories, never modifies or removes existing ones.
+ * Idempotent: only adds missing categories, never modifies or removes existing ones
+ * (a project parent that exists without the flag is marked `is_parent` so its
+ * children can sit under it).
  *
  * @returns {{ created: string[], total: number }}
  */
-export function ensureProjectCategories() {
-  const projects = loadRegisteredProjects();
+function addMissingCategories(mutate) {
   const catPath = getMcpCategoriesPath();
-
-  let data;
-  try {
-    data = JSON.parse(readFileSync(catPath, 'utf-8'));
-  } catch {
-    data = { version: 1, categories: [] };
+  let data = { version: 1, categories: [] };
+  if (existsSync(catPath)) {
+    try { data = JSON.parse(readFileSync(catPath, 'utf-8')); } catch { return { created: [], total: 0 }; }
+    if (!data || !Array.isArray(data.categories)) return { created: [], total: 0 };
   }
+  const categories = data.categories;
+  const created = mutate(categories, new Date().toISOString());
+  if (created.length > 0) {
+    data.version = data.version || 1;
+    mkdirSync(dirname(catPath), { recursive: true });
+    writeFileSync(catPath, JSON.stringify(data, null, 2), 'utf-8');
+  }
+  return { created, total: categories.length };
+}
 
-  const categories = data.categories || [];
-  const existingNames = new Set(categories.map((c) => c.name));
-  const created = [];
-  const now = new Date().toISOString();
-
-  // 1. Ensure standalone defaults exist
-  for (const def of STANDALONE_DEFAULTS) {
-    if (!existingNames.has(def.name)) {
-      const cat = { name: def.name, description: def.description, created_at: now };
-      if (def.is_parent) cat.is_parent = true;
+/**
+ * Create categories the first time something saves into them.
+ * `defs`: [{ name, description, parent?, is_parent?, color? }], parents first. A
+ * parent is attached only when it exists (or is created by an earlier def).
+ *
+ * @returns {{ created: string[], total: number }}
+ */
+export function ensureCategories(defs) {
+  return addMissingCategories((categories, now) => {
+    const names = new Set(categories.map((c) => c.name));
+    const created = [];
+    for (const def of defs || []) {
+      if (!def?.name || names.has(def.name)) continue;
+      const cat = { name: def.name, description: def.description || def.name, created_at: now };
+      if (def.parent && names.has(def.parent)) cat.parent = def.parent;
+      else if (def.is_parent) cat.is_parent = true;
       if (def.color) cat.color = def.color;
       categories.push(cat);
-      existingNames.add(def.name);
+      names.add(def.name);
       created.push(def.name);
     }
-  }
-
-  // 2. Ensure project parents + children exist
-  for (const proj of projects) {
-    let label = normalizeLabel(proj.label);
-    // Truncate to 16 chars so children stay within 30-char limit (16 + 1 + 12 = 29)
-    if (label.length > 16) label = label.slice(0, 16).replace(/-$/, '');
-
-    // Ensure parent exists
-    if (!existingNames.has(label)) {
-      categories.push({
-        name: label,
-        description: `Knowledge and context for the ${proj.label} project`,
-        is_parent: true,
-        created_at: now,
-      });
-      existingNames.add(label);
-      created.push(label);
-    } else {
-      // Parent exists — ensure it has is_parent flag
-      const existing = categories.find((c) => c.name === label);
-      if (existing && !existing.is_parent) existing.is_parent = true;
-    }
+    return created;
+  });
+}
 
-    // Ensure each default child exists
-    for (const child of PROJECT_CHILDREN) {
-      const childName = `${label}-${child.suffix}`;
-      if (!existingNames.has(childName)) {
+/**
+ * Create a project's parent category with the default children, once: at the moment
+ * the project is registered (the Neural Interface's add-project route, the only
+ * writer of the registry). Never called for a project that was already registered,
+ * so a default category the user deleted stays deleted.
+ *
+ * @param {Array<{ label: string }>} projects — the project(s) just registered
+ * @returns {{ created: string[], total: number }}
+ */
+export function ensureProjectCategories(projects) {
+  return addMissingCategories((categories, now) => {
+    const existingNames = new Set(categories.map((c) => c.name));
+    const created = [];
+    for (const proj of projects || []) {
+      if (!proj?.label) continue;
+      const label = projectCategoryLabel(proj.label);
+      if (!label) continue;
+
+      // Ensure parent exists
+      if (!existingNames.has(label)) {
         categories.push({
-          name: childName,
-          description: `${child.description} for ${proj.label}`,
-          parent: label,
+          name: label,
+          description: `Knowledge and context for the ${proj.label} project`,
+          is_parent: true,
           created_at: now,
         });
-        existingNames.add(childName);
-        created.push(childName);
+        existingNames.add(label);
+        created.push(label);
+      } else {
+        // Parent exists — ensure it has is_parent flag
+        const existing = categories.find((c) => c.name === label);
+        if (existing && !existing.is_parent && !existing.parent) existing.is_parent = true;
       }
-    }
-  }
 
-  // Only write if we created something new
-  if (created.length > 0) {
-    data.categories = categories;
-    writeFileSync(catPath, JSON.stringify(data, null, 2), 'utf-8');
-  }
-
-  return { created, total: categories.length };
+      // Ensure each default child exists
+      for (const child of PROJECT_CHILDREN) {
+        const childName = `${label}-${child.suffix}`;
+        if (!existingNames.has(childName)) {
+          categories.push({
+            name: childName,
+            description: `${child.description} for ${proj.label}`,
+            parent: label,
+            created_at: now,
+          });
+          existingNames.add(childName);
+          created.push(childName);
+        }
+      }
+    }
+    return created;
+  });
 }
 
 /**
@@ -1180,9 +1214,11 @@ const LOOP_STALE_INACTIVITY_MS = 45 * 60 * 1000; // 45 min — browser iteration
  * Scan loop directory and delete stale/inactive loop files.
  * No history keeping — ended loops are removed immediately.
  *
- * A loop is stale if:
- * 1. active + exceeded its maxMinutes + 5min grace
- * 2. active + no iteration activity for 10 minutes (session died)
+ * A loop is stale if it is active with no iteration activity for 45 minutes
+ * (session died). A dispatched worker's file (runMode 'task') is never swept
+ * here: its one iteration lasts the whole run, which idles warm between turns
+ * for far longer, and the server ends it (work-time cap, idle timeout, and
+ * marks it inactive after a restart).
  *
  * @param {string} loopDir - path to data/loop/
  * @returns {{ deactivated: string[], deleted: string[] }}
@@ -1201,6 +1237,7 @@ export function cleanupStaleLoops(loopDir) {
         const loop = JSON.parse(readFileSync(fp, 'utf-8'));
 
         if (loop.active) {
+          if (loop.runMode === 'task') continue;
           const lastActivity = new Date(loop.lastIterationAt || loop.startedAt || 0).getTime();
           const noRecentActivity = (now - lastActivity) >= LOOP_STALE_INACTIVITY_MS;
 

package/lib/child-path.js

@@ -0,0 +1,303 @@
+/**
+ * SynaBun — the PATH of everything SynaBun starts, and where npm puts global commands
+ *
+ * A packaged application (packaging/) brings its own Node runtime, npm and npx.
+ * They are a fallback: on the PATH of every process the application starts,
+ * the order is
+ *
+ *   1. the user's own PATH, as it came
+ *   2. the bin folder of npm's global prefix, when the PATH lacks it (where
+ *      `npm i -g` through SynaBun's npm puts commands: the user's own prefix
+ *      when they set one, else a per-user folder of SynaBun's, never the app)
+ *   3. the packaged runtime, last
+ *
+ * packagedPathLast() is that order, and the one implementation of it: the
+ * entry points of a packaged build (lib/packaged-runtime.js packagedChildEnv:
+ * the bootstrap, the hook handler, the headless MCP server) and every PATH the
+ * Neural Interface builds (neural-interface/lib/augmented-path.js) use it.
+ *
+ * npm's global prefix is read here the way npm 10 (@npmcli/config) settles it,
+ * from plain files, without starting npm:
+ *
+ *   1. the environment: npm_config_prefix, in any letter case, when not empty
+ *   2. the user's config file: npm_config_userconfig, else ~/.npmrc
+ *   3. the global config file: npm_config_globalconfig, else `globalconfig=` in
+ *      the user's (or the builtin) file, else <the prefix so far>/etc/npmrc
+ *   4. the builtin config of that npm (<npm>/npmrc: a packaged build writes one)
+ *   5. the default: $PREFIX, else the folder of the node running npm (Windows)
+ *      or the folder above it
+ *
+ * (The command line comes first for npm and is never known here; a project's
+ * .npmrc is ignored by npm for a global install.) Every value goes through
+ * npm's ${VAR} substitution; a path then has a leading `~/` (on Windows also
+ * `~\`) replaced by the home folder (HOME, else the account's) and is made
+ * absolute. Files are read as npm's ini reader reads them: `;` and `#`
+ * comments, quotes, inline comments; a `prefix` inside a [section] is not the
+ * prefix. One difference: an empty `prefix=` counts as not set (npm would use
+ * the folder it happens to run in, which is no folder to put on a PATH).
+ *
+ * Only node: modules here: neural-interface/lib/augmented-path.js imports this
+ * file, and tests copy both into scratch trees.
+ */
+
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+
+const MEMO_MS = 5_000;
+let _memo = null; // { key, at, value }
+
+const implFor = (platform) => (platform === 'win32' ? path.win32 : path.posix);
+
+/** The value of an env's PATH, whatever its spelling (Windows: Path). */
+export function pathEnvValue(env = process.env) {
+  return env[Object.keys(env).find(key => key.toUpperCase() === 'PATH')] || '';
+}
+
+/**
+ * `env` with PATH set to `value`. Windows environment names are
+ * case-insensitive and JS object keys are not: the base's spelling is kept and
+ * every alias removed before an env reaches Node or ConPTY.
+ */
+export function withPathEnv(env = process.env, value = pathEnvValue(env), platform = process.platform) {
+  if (platform !== 'win32') return { ...env, PATH: value };
+  const keys = Object.keys(env).filter(key => key.toUpperCase() === 'PATH');
+  const key = keys[0] || 'Path';
+  const out = { ...env };
+  for (const alias of keys) delete out[alias];
+  out[key] = value;
+  return out;
+}
+
+/**
+ * PATH `value` with a packaged application's folders after the user's: each
+ * `extra` folder (npm's global bin) appended when the PATH does not have it
+ * yet, then every `last` folder (the runtime) moved to the very end. Nothing
+ * else moves; each folder stays once (Windows compares without case and
+ * trailing separators).
+ */
+export function packagedPathLast(value, { platform = process.platform, last = [], extra = [] } = {}) {
+  const delimiter = platform === 'win32' ? ';' : ':';
+  const id = (entry) => (platform === 'win32' ? entry.toLowerCase().replace(/[\\/]+$/, '') : entry.replace(/\/+$/, '') || '/');
+  const lastIds = new Set(last.filter(Boolean).map(id));
+  const seen = new Set();
+  const out = [];
+  const add = (entry) => {
+    if (!entry) return;
+    const key = id(entry);
+    if (seen.has(key)) return;
+    seen.add(key);
+    out.push(entry);
+  };
+  for (const entry of String(value || '').split(delimiter)) if (entry && !lastIds.has(id(entry))) add(entry);
+  for (const entry of extra) if (entry && !lastIds.has(id(entry))) add(entry);
+  for (const entry of last) add(entry);
+  return out.join(delimiter);
+}
+
+/** Where npm puts the commands of global packages under `prefix`: the prefix itself on Windows, its bin/ elsewhere. */
+export function npmGlobalBinFor(prefix, platform = process.platform) {
+  if (!prefix) return null;
+  return platform === 'win32' ? prefix : implFor(platform).join(prefix, 'bin');
+}
+
+/** The builtin npmrc of the npm in a packaged runtime whose executables are in `runtimeBin`. */
+export function bundledNpmrcPath(runtimeBin, platform = process.platform) {
+  if (!runtimeBin) return null;
+  const impl = implFor(platform);
+  return platform === 'win32'
+    ? impl.join(runtimeBin, 'node_modules', 'npm', 'npmrc')
+    : impl.join(runtimeBin, '..', 'lib', 'node_modules', 'npm', 'npmrc');
+}
+
+function envLookup(env, name, platform) {
+  if (env[name] !== undefined) return env[name];
+  if (platform !== 'win32') return undefined;
+  const key = Object.keys(env).find(candidate => candidate.toUpperCase() === name.toUpperCase());
+  return key === undefined ? undefined : env[key];
+}
+
+/**
+ * npm's ${VAR} substitution (@npmcli/config env-replace.js): `${NAME}` is the
+ * variable's value, a name that is not set stays as written, and a backslash
+ * before `${` escapes it (an even number of them is that many halved, then the value).
+ */
+export function npmEnvReplace(text, env = process.env, platform = process.platform) {
+  return String(text).replace(/(?<!\\)(\\*)\$\{([^${}]+)\}/g, (orig, esc, name) => {
+    const found = envLookup(env, name, platform);
+    const value = found !== undefined ? found : `\${${name}}`;
+    if (esc.length % 2) return orig.slice((esc.length + 1) / 2);
+    return esc.slice(esc.length / 2) + value;
+  });
+}
+
+// The ini reader npm uses (ini 4.x unsafe()): quotes, then `;` / `#` ending the value unless escaped.
+function iniValue(raw) {
+  let value = String(raw || '').trim();
+  if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+    if (value.charAt(0) === "'") value = value.slice(1, -1);
+    try { value = JSON.parse(value); } catch { /* kept as it is */ }
+    return value;
+  }
+  let escaped = false;
+  let out = '';
+  for (const char of value) {
+    if (escaped) {
+      out += '\\;#'.includes(char) ? char : `\\${char}`;
+      escaped = false;
+    } else if (char === ';' || char === '#') {
+      break;
+    } else if (char === '\\') {
+      escaped = true;
+    } else {
+      out += char;
+    }
+  }
+  if (escaped) out += '\\';
+  return out.trim();
+}
+
+/**
+ * The top-level settings of an .npmrc, as npm's ini reader gives them (a key
+ * inside a [section] is the section's; `true` / `false` / `null` are those
+ * values; `key[]` makes a list; the last of a repeated key wins).
+ */
+export function parseNpmrc(text) {
+  const out = Object.create(null);
+  for (const line of String(text || '').split(/[\r\n]+/g)) {
+    if (!line || /^\s*[;#]/.test(line) || /^\s*$/.test(line)) continue;
+    if (/^\[([^\]]*)\]\s*$/.test(line)) break;
+    const match = line.match(/^([^=]+)(=(.*))?$/);
+    if (!match) continue;
+    const rawKey = iniValue(match[1]);
+    const isList = rawKey.length > 2 && rawKey.endsWith('[]');
+    const key = isList ? rawKey.slice(0, -2) : rawKey;
+    if (!key || key === '__proto__') continue;
+    const raw = match[2] ? iniValue(match[3]) : true;
+    const value = raw === 'true' || raw === 'false' || raw === 'null' ? JSON.parse(raw) : raw;
+    if (isList) {
+      if (!Array.isArray(out[key])) out[key] = out[key] === undefined ? [] : [out[key]];
+    }
+    if (Array.isArray(out[key])) out[key].push(value);
+    else out[key] = value;
+  }
+  return out;
+}
+
+/** The npm_config_* settings of an environment, as npm reads them (any letter case, `_` as `-`, empty ones skipped; the last spelling wins). */
+export function npmEnvConfig(env = process.env) {
+  const out = Object.create(null);
+  for (const [name, value] of Object.entries(env)) {
+    if (!/^npm_config_/i.test(name) || value === '' || value === undefined) continue;
+    let key = name.slice('npm_config_'.length);
+    if (!key.startsWith('//')) key = key.replace(/(?!^)_/g, '-').toLowerCase();
+    out[key] = value;
+  }
+  return out;
+}
+
+/** A path setting as npm parses it: ${VAR}, then `~/`, then absolute. null for one that is not a usable string. */
+export function npmPathValue(value, { env = process.env, platform = process.platform, home, cwd = process.cwd() } = {}) {
+  if (typeof value !== 'string') return null;
+  const text = npmEnvReplace(value.trim(), env, platform);
+  if (!text) return null;
+  const impl = implFor(platform);
+  const homePattern = platform === 'win32' ? /^~(\/|\\)/ : /^~\//;
+  if (homePattern.test(text) && home) return impl.resolve(home, text.slice(2));
+  return impl.resolve(cwd, text);
+}
+
+/** The home folder npm uses: HOME, else the account's (os.homedir(); on Windows USERPROFILE). */
+export function npmHome(env = process.env, platform = process.platform) {
+  if (env.HOME) return env.HOME;
+  if (env === process.env) return homedir();
+  if (platform === 'win32') return envLookup(env, 'USERPROFILE', platform) || homedir();
+  return homedir();
+}
+
+/**
+ * npm's global prefix, as described at the top. `builtin` is the builtin npmrc
+ * of the npm that will run (lib/packaged-runtime.js names the packaged one),
+ * `execPath` the node it runs on (for the default); leave both out to get only
+ * what the user set (`source` then never says 'builtin' or 'default').
+ *
+ * Returns { prefix, bin, source, from, userconfig, globalconfig }: `prefix` an
+ * absolute folder or null, `source` 'env' | 'userconfig' | 'globalconfig' |
+ * 'builtin' | 'default' | null, `from` what set it (the variable or the file).
+ */
+export function resolveNpmPrefix({
+  env = process.env,
+  platform = process.platform,
+  home = npmHome(env, platform),
+  cwd = process.cwd(),
+  readFile = readFileSync,
+  builtin = null,
+  execPath = null,
+} = {}) {
+  const impl = implFor(platform);
+  const parse = { env, platform, home, cwd };
+  const read = (file) => {
+    if (!file) return Object.create(null);
+    try { return parseNpmrc(readFile(file, 'utf8')); } catch { return Object.create(null); }
+  };
+  const fromEnv = npmEnvConfig(env);
+  const envPrefix = npmPathValue(fromEnv.prefix, parse);
+  const userconfig = npmPathValue(fromEnv.userconfig, parse) || (home ? impl.resolve(home, '.npmrc') : null);
+  const user = read(userconfig);
+  const userPrefix = npmPathValue(user.prefix, parse);
+  const builtinConfig = read(builtin);
+  const builtinPrefix = npmPathValue(builtinConfig.prefix, parse);
+  let defaultPrefix = null;
+  if (execPath) {
+    if (env.PREFIX) defaultPrefix = npmPathValue(env.PREFIX, parse);
+    else if (platform === 'win32') defaultPrefix = impl.dirname(execPath);
+    else defaultPrefix = env.DESTDIR ? impl.join(env.DESTDIR, impl.dirname(impl.dirname(execPath))) : impl.dirname(impl.dirname(execPath));
+  }
+  const soFar = envPrefix || userPrefix || builtinPrefix || defaultPrefix;
+  const globalconfig = npmPathValue(fromEnv.globalconfig, parse)
+    || npmPathValue(user.globalconfig, parse)
+    || npmPathValue(builtinConfig.globalconfig, parse)
+    || (soFar ? impl.resolve(soFar, 'etc', 'npmrc') : null);
+  const globalPrefix = npmPathValue(read(globalconfig).prefix, parse);
+  const levels = [
+    ['env', envPrefix, 'npm_config_prefix'],
+    ['userconfig', userPrefix, userconfig],
+    ['globalconfig', globalPrefix, globalconfig],
+    ['builtin', builtinPrefix, builtin],
+    ['default', defaultPrefix, execPath],
+  ];
+  const found = levels.find(([, value]) => value);
+  const prefix = found ? found[1] : null;
+  return {
+    prefix,
+    bin: npmGlobalBinFor(prefix, platform),
+    source: found ? found[0] : null,
+    from: found ? found[2] : null,
+    userconfig,
+    globalconfig,
+  };
+}
+
+/**
+ * resolveNpmPrefix() for this process, kept for a few seconds: every PATH
+ * SynaBun builds asks, and a changed ~/.npmrc counts within seconds. Options
+ * other than `builtin` and `execPath` (an env that is not process.env, a
+ * readFile) are not cached.
+ */
+export function effectiveNpmPrefix(options = {}) {
+  const { builtin = null, execPath = null, ...rest } = options;
+  const live = Object.keys(rest).every(key => (key === 'env' ? rest.env === process.env : key === 'platform' ? rest.platform === process.platform : false));
+  if (!live) return resolveNpmPrefix(options);
+  const env = process.env;
+  const relevant = Object.entries(env).filter(([name]) => /^npm_config_/i.test(name) || ['HOME', 'USERPROFILE', 'APPDATA', 'PREFIX', 'DESTDIR'].includes(name.toUpperCase()));
+  const key = JSON.stringify([builtin, execPath, process.cwd(), relevant]);
+  if (_memo && _memo.key === key && Date.now() - _memo.at < MEMO_MS) return _memo.value;
+  const value = resolveNpmPrefix({ builtin, execPath });
+  _memo = { key, at: Date.now(), value };
+  return value;
+}
+
+/** Forget what effectiveNpmPrefix() keeps (a test, or a settings change that must count at once). */
+export function forgetNpmPrefix() {
+  _memo = null;
+}

package/lib/claude-hooks.js

@@ -78,7 +78,8 @@ export function isSynaBunHookCommand(command, scriptName) {
 /**
  * Why this run must not write hook commands, or null when it may. A packaged
  * application with no path that outlives the run (macOS started it from a
- * temporary copy) would leave every handler pointing at nothing.
+ * temporary copy, or from the disk image it came in) would leave every handler
+ * pointing at nothing.
  */
 export function hookInstallBlocker(runtime = packagedRuntime()) {
   if (!runtime || durableEntry(runtime)) return null;

package/lib/data-home-migration.js

@@ -52,6 +52,8 @@ function isRuntimeOnlyMigrationFile(relativePath) {
   return name === '.DS_Store'
     || MIGRATION_RUNTIME_ONLY_FILES.has(normalized)
     || /(?:^|\/)server-(?:stdout|stderr)\.log(?:\.1)?$/i.test(normalized)
+    // The desktop app's own log (packaging/desktop) and the launcher's rotated one, written from the first start on.
+    || /^data\/(?:desktop\.log(?:\.1)?|launcher\.log\.1)$/i.test(normalized)
     || /(?:^|\/)(?:restart-requested|opencode-managed\.pid)$/i.test(normalized);
 }