total-recall-brain 3.43.0 → 3.43.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "total-recall-brain",
-  "version": "3.43.0",
+  "version": "3.43.2",
   "description": "The Vibe Coding Brain & Autonomous Software Factory: memory, rules, secrets, and 33 visual plugins automatically managed across all your devices.",
   "type": "module",
   "bin": {

package/scaffold/.agent/skills/total-recall/plugins/ssss/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "tr-plugin-ssss",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "tr-plugin-ssss",
-      "version": "0.1.1",
+      "version": "0.1.2",
       "license": "MIT",
       "dependencies": {
         "@gregiteen/ssss-cli": "0.14.4"

package/scaffold/.agent/skills/total-recall/plugins/ssss/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tr-plugin-ssss",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "private": true,
   "type": "module",
   "description": "Canonical SSSS distribution, scaffolding and validation for Total Recall installations.",

package/scaffold/.agent/skills/total-recall/plugins/ssss/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://github.com/gregiteen/total-recall/blob/main/metadata.plugin.schema.json",
   "id": "ssss",
   "name": "SSSS",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Canonical SSSS distribution, scaffolding and validation for Total Recall installations.",
   "license": "MIT",
   "use_cases": ["software-development", "state-conformance"],

package/scaffold/.agent/skills/total-recall/plugins/ssss/runtime/installation.cjs

@@ -99,16 +99,25 @@ function inspectScaffold(dir, source) {
   return { ok: true, path: dir, files: Object.keys(expected.files).length };
 }
 
-function skillRootFor(target, sharedBrainDir) {
-  if (!stat(target)?.isSymbolicLink()) return target;
-  const sharedSkill = sharedBrainDir && path.join(path.dirname(sharedBrainDir), 'ssss');
-  const resolved = fs.realpathSync(target);
-  if (!sharedSkill || resolved !== sharedSkill) throw new Error('SSSS skill points outside the shared skill installation');
-  return resolved;
+const realOrNull = file => { try { return fs.realpathSync(file); } catch { return null; } };
+/** A path with its folders resolved and its last part kept, so a link is compared as itself. */
+const entryOf = file => path.join(realOrNull(path.dirname(file)) ?? path.dirname(file), path.basename(file));
+
+/**
+ * True for a project's link to the machine's shared skill. A link at the shared location itself
+ * is not one: that location is what has to hold the skill.
+ */
+function linksToSharedSkill(target, sharedBrainDir) {
+  if (!sharedBrainDir) return false;
+  const shared = path.join(path.dirname(sharedBrainDir), 'ssss');
+  if (entryOf(shared) === entryOf(target)) return false;
+  const resolved = realOrNull(target);
+  return resolved !== null && resolved === realOrNull(shared);
 }
 
-function inspectSkill(target, source, sharedBrainDir) {
-  const dir = skillRootFor(target, sharedBrainDir);
+/** A link that reaches a complete, current skill is left alone, like a linked plugin. */
+function inspectSkill(target, source) {
+  const dir = stat(target)?.isSymbolicLink() ? fs.realpathSync(target) : target;
   requireDirectory(dir);
   const wrapper = fs.readFileSync(regularPath(dir, 'SKILL.md'), 'utf8');
   if (!/^name:\s*['"]?ssss['"]?\s*$/m.test(wrapper) || !wrapper.includes('core/SKILL.md')) {
@@ -164,31 +173,63 @@ function writeAsset(root, relative, content) {
   fs.writeFileSync(file, content, { flag: 'wx' });
 }
 
+const NAMES_THIS_SKILL = /^name:\s*['"]?ssss['"]?\s*$/m;
+
+/** Fill a staged skill: any files already there stay, and the portable core is always replaced. */
+function completeSkill(stage, source) {
+  fs.rmSync(path.join(stage, 'core'), { recursive: true, force: true });
+  for (const relative of Object.keys(source.skill)) {
+    if (!stat(regularPath(stage, relative))) {
+      writeAsset(stage, relative, fs.readFileSync(regularPath(source.skillRoot, relative)));
+    }
+  }
+  const wrapper = path.join(stage, 'SKILL.md');
+  if (!fs.readFileSync(wrapper, 'utf8').includes('core/SKILL.md')) fs.appendFileSync(wrapper, ROUTE);
+  inspectSkill(stage, source);
+}
+
+/**
+ * An older layout linked the skill in, and the link is now dangling or stale. Only the link is
+ * replaced: nothing is written through it, so whatever it pointed at stays exactly as it was.
+ * A wrapper with this skill's name carries over, because it can hold repository guidance.
+ */
+function replaceLink(target, source) {
+  const pointsAt = fs.readlinkSync(target);
+  let wrapper = null;
+  try {
+    const text = fs.readFileSync(path.join(target, 'SKILL.md'), 'utf8');
+    if (NAMES_THIS_SKILL.test(text)) wrapper = text;
+  } catch { /* a dangling link or a folder with no entry has no wrapper to keep */ }
+  publishDirectory(target, stage => {
+    if (wrapper) writeAsset(stage, 'SKILL.md', wrapper);
+    completeSkill(stage, source);
+  }, true);
+  return { path: target, target: pointsAt };
+}
+
+/** @returns {{ path: string, target: string } | undefined} the link it replaced, if it replaced one */
 function installSkill(target, source, sharedBrainDir) {
-  const dir = skillRootFor(target, sharedBrainDir);
-  if (dir !== target) return inspectSkill(target, source, sharedBrainDir);
-  checkRoot(dir);
-  const exists = Boolean(stat(dir));
+  if (stat(target)?.isSymbolicLink()) {
+    if (!linksToSharedSkill(target, sharedBrainDir)) return replaceLink(target, source);
+    // The shared skill is repaired where it lives. A project does not take a private copy.
+    inspectSkill(target, source);
+    return undefined;
+  }
+  checkRoot(target);
+  const exists = Boolean(stat(target));
   // Stage the complete skill so a failed source read cannot leave a partial skill.
   if (exists) {
-    const wrapper = regularPath(dir, 'SKILL.md');
-    if (stat(wrapper) && !/^name:\s*['"]?ssss['"]?\s*$/m.test(fs.readFileSync(wrapper, 'utf8'))) {
-      throw new Error('Existing skill directory belongs to another skill: ' + dir);
+    const wrapper = regularPath(target, 'SKILL.md');
+    if (stat(wrapper) && !NAMES_THIS_SKILL.test(fs.readFileSync(wrapper, 'utf8'))) {
+      throw new Error('Existing skill directory belongs to another skill: ' + target);
     }
-    listFiles(dir);
+    listFiles(target);
   }
-  publishDirectory(dir, stage => {
-    if (exists) fs.cpSync(dir, stage, { recursive: true });
-    fs.rmSync(path.join(stage, 'core'), { recursive: true, force: true });
-    for (const relative of Object.keys(source.skill)) {
-      if (!stat(regularPath(stage, relative))) {
-        writeAsset(stage, relative, fs.readFileSync(regularPath(source.skillRoot, relative)));
-      }
-    }
-    const wrapper = path.join(stage, 'SKILL.md');
-    if (!fs.readFileSync(wrapper, 'utf8').includes('core/SKILL.md')) fs.appendFileSync(wrapper, ROUTE);
-    inspectSkill(stage, source);
+  publishDirectory(target, stage => {
+    if (exists) fs.cpSync(target, stage, { recursive: true });
+    completeSkill(stage, source);
   }, exists);
+  return undefined;
 }
 
 function hasUpdaterDrift(dir, source, receipt) {
@@ -247,7 +288,7 @@ function inspectInstalled(options, source) {
     catch (error) { return { ok: false, path: target, error: error.message }; }
   };
   const observed = {
-    skill: check(skill, () => inspectSkill(skill, source, options.sharedBrainDir)),
+    skill: check(skill, () => inspectSkill(skill, source)),
     scaffold: check(scaffold, () => {
       checkRoot(options.brainDir);
       checkRoot(path.dirname(scaffold));
@@ -269,10 +310,10 @@ function ensureInstallation(options) {
   checkRoot(options.brainDir);
   const current = inspectInstalled(options, source);
   const recoveredFrom = current.scaffold.ok ? undefined : installScaffold(scaffold, source, options.repair === true);
-  if (!current.skill.ok) installSkill(skill, source, options.sharedBrainDir);
+  const replacedLink = current.skill.ok ? undefined : installSkill(skill, source, options.sharedBrainDir);
   const installed = inspectInstalled(options, source);
   if (!installed.ok) throw new Error([installed.skill.error, installed.scaffold.error].filter(Boolean).join('; '));
-  return recoveredFrom ? { ...installed, recoveredFrom } : installed;
+  return { ...installed, ...(recoveredFrom ? { recoveredFrom } : {}), ...(replacedLink ? { replacedLink } : {}) };
 }
 
 async function maintain({ brainDir, entries, apply, run }) {

package/src/cli/release.mjs

@@ -197,11 +197,13 @@ export function consumerState(root, pkg, version = null) {
   const declaredFiles = [];
   const pkgFile = path.join(root, 'package.json');
   let declared = null;
+  let devOnly = false;
   if (fs.existsSync(pkgFile)) {
     try {
       const j = JSON.parse(fs.readFileSync(pkgFile, 'utf8'));
       const all = { ...(j.dependencies || {}), ...(j.devDependencies || {}), ...(j.optionalDependencies || {}) };
       declared = all[pkg] ?? null;
+      devOnly = Boolean(j.devDependencies?.[pkg]) && !j.dependencies?.[pkg] && !j.optionalDependencies?.[pkg];
       if (declared) declaredFiles.push(pkgFile);
     } catch {
       /* unreadable package.json is reported as unknown, not as satisfied */
@@ -243,7 +245,15 @@ export function consumerState(root, pkg, version = null) {
       /* keep looking */
     }
   }
-  const satisfied = range ? Boolean(installed) && installed === version : Boolean(want && installed === want);
+  // A checkout with no copy of a dev dependency runs under the shared install. Nothing there is stale.
+  if (!installed && devOnly) {
+    return { root, declared, want, range, installed: null, satisfied: true, pinBehind: false, devNotInstalled: true, reason: 'dev-not-installed' };
+  }
+  // What a consumer runs is what counts, and the version named is the question. A pin can lag on
+  // purpose, because `update` installs plugin copies with --no-save. Comparing against the pin
+  // would fail those and pass a consumer whose pin and install both lag.
+  const expected = version || want;
+  const satisfied = Boolean(expected && installed === expected);
   return {
     root,
     declared,
@@ -251,6 +261,7 @@ export function consumerState(root, pkg, version = null) {
     range,
     installed,
     satisfied,
+    pinBehind: Boolean(satisfied && want && want !== installed),
     reason: !installed ? 'not-installed' : satisfied ? 'ok' : 'installed-mismatch',
   };
 }
@@ -279,6 +290,8 @@ export function verifyConsumers(pkg, version, opts = {}) {
     consumers: relevant.length,
     failing: failing.length,
     failures: failing.map((s) => ({ root: s.root, declared: s.declared, installed: s.installed, reason: s.reason })),
+    pin_behind: relevant.filter((s) => s.pinBehind).map((s) => ({ root: s.root, declared: s.declared, installed: s.installed })),
+    dev_not_installed: relevant.filter((s) => s.devNotInstalled).map((s) => s.root),
   };
 }
 
@@ -362,6 +375,8 @@ export async function run(argv = process.argv, deps = {}) {
         return fail(`${pkg}@${version}: ${consumers.failing}/${consumers.consumers} consumers not satisfied. First: ${consumers.failures[0].root} (${consumers.failures[0].installed ?? 'not installed'}).`);
       }
       log(`  ✓ ${pkg}@${version} verified: registry + ${consumers.consumers}/${consumers.consumers} consumers`);
+      if (consumers.pin_behind.length) log(`    ${consumers.pin_behind.length} run it with an older pin in package.json, such as ${consumers.pin_behind[0].root}`);
+      if (consumers.dev_not_installed.length) log(`    ${consumers.dev_not_installed.length} keep no dev copy of it and run under the shared install`);
       continue;
     }
 

package/src/core/automatic-brain-updates.mjs

@@ -40,7 +40,9 @@ export async function runAutomaticBrainUpdates({brainDir,fleet=false,force=false
   if(!force && !isPackageAutoUpdateEnabled())return {skipped:true,reason:'disabled',results:[]};
   const file=path.join(brainDir,'memory-derived/automatic-brain-updates.json');
   let saved;try{saved=JSON.parse(fs.readFileSync(file,'utf8'));}catch{}
-  const delay=saved?.failed?Math.min(intervalMs,5*60*1000):intervalMs;
+  // Fast retry is for this machine's own failures. A peer with no update transport fails every
+  // run, and counting it made maintenance run back to back forever.
+  const delay=(saved?.local_failed??saved?.failed)?Math.min(intervalMs,5*60*1000):intervalMs;
   if(!force && !skipThrottle && saved?.checkedAt && now()>=saved.checkedAt && now()-saved.checkedAt<delay)return {skipped:true,reason:'throttled',results:[]};
   fs.mkdirSync(path.dirname(file),{recursive:true});
   const lock=`${file}.lock`;

package/src/core/brain-updates.mjs

@@ -185,6 +185,22 @@ function targetSpec(key, version) {
 }
 
 /** Dry by default. Resolve releases once; install independently; verify actual resolution. */
+/**
+ * A checkout that keeps no copy of a dev dependency runs under the shared install, so it has no
+ * old version to replace. Its pin stays current, and its dev tree is its owner's to install: one
+ * plugin's tree is about 460 MB, so restoring them all automatically could fill a disk.
+ */
+const absentDevDep = (dep) => dep.section === 'devDependencies' && !dep.file;
+
+/**
+ * The daemon runs with NODE_ENV=production, and under that npm and pnpm remove dev dependencies
+ * from whatever they install in. An install that wants a runtime tree says so with a flag.
+ */
+function installEnv(env = process.env) {
+  const { NODE_ENV, npm_config_omit, NPM_CONFIG_OMIT, npm_config_production, NPM_CONFIG_PRODUCTION, ...kept } = env;
+  return kept;
+}
+
 export async function updateAllBrains(opts = {}) {
   const dryRun = opts.dryRun !== false;
   const exec = opts.exec || spawnSync;
@@ -245,9 +261,12 @@ export async function updateAllBrains(opts = {}) {
       row.status = 'failed'; row.error = 'Newer local/preview package; refusing an implicit downgrade'; continue;
     }
     const shared = isLink(path.join(owner.owner, 'node_modules')) || isLink(path.join(consumer.root, 'node_modules'));
-    const needsChange = shared || consumer.deps.some(dep => dep.version !== versions[dep.package]
-      || (!consumer.runtimeOnly && dep.declared !== targetSpec(dep.key, versions[dep.package]))
-      || !dep.file?.startsWith(path.join(owner.owner, 'node_modules') + path.sep));
+    const needsChange = shared || consumer.deps.some(dep => {
+      const pinLags = !consumer.runtimeOnly && dep.declared !== targetSpec(dep.key, versions[dep.package]);
+      if (absentDevDep(dep)) return pinLags;
+      return pinLags || dep.version !== versions[dep.package]
+        || !dep.file?.startsWith(path.join(owner.owner, 'node_modules') + path.sep);
+    });
     if (!needsChange) continue;
     row.status = dryRun ? 'would_update' : 'pending';
     if (!groups.has(owner.owner)) groups.set(owner.owner, { ...owner, consumers: [] });
@@ -264,8 +283,8 @@ export async function updateAllBrains(opts = {}) {
     const runtimeOnly = group.consumers.every(({ consumer }) => consumer.runtimeOnly);
     const unpinned = runtimeOnly && group.manager === 'npm';
     const needsInstall = group.consumers.some(({ consumer }) =>
-      isLink(path.join(consumer.root, 'node_modules')) || consumer.deps.some(dep =>
-        dep.version !== versions[dep.package] || !dep.file?.startsWith(path.join(group.owner, 'node_modules') + path.sep)));
+      isLink(path.join(consumer.root, 'node_modules')) || consumer.deps.some(dep => !absentDevDep(dep)
+        && (dep.version !== versions[dep.package] || !dep.file?.startsWith(path.join(group.owner, 'node_modules') + path.sep))));
     try {
       lockFd = acquireBrainUpdateLock(lock, opts.lockWaitMs === undefined ? {} : { waitMs: opts.lockWaitMs });
       for (const name of ['package-lock.json', 'npm-shrinkwrap.json', 'pnpm-lock.yaml']) {
@@ -294,7 +313,7 @@ export async function updateAllBrains(opts = {}) {
       if (unpinned) args.push('--no-save', ...new Set(group.consumers.flatMap(({ consumer }) =>
         consumer.deps.map(dep => `${dep.key}@${targetSpec(dep.key, versions[dep.package])}`))));
       else if (!needsInstall) args.push(group.manager === 'pnpm' ? '--lockfile-only' : '--package-lock-only');
-      const install = exec(group.manager, args, { cwd: group.owner, encoding: 'utf8',
+      const install = exec(group.manager, args, { cwd: group.owner, env: installEnv(), encoding: 'utf8',
         timeout: 600000, maxBuffer: 8 * 1024 * 1024 });
       if (install.status !== 0) throw new Error(install.error?.message || install.stderr?.trim().slice(-1500) || `Install exited ${install.status}`);
       for (const { consumer, row } of group.consumers) {
@@ -309,6 +328,7 @@ export async function updateAllBrains(opts = {}) {
         const placed = (file) => Boolean(file) && allowedRoots.some((root) => file.startsWith(root));
         const bad = consumer.deps.find(dep => {
           const actual = installedBrainPackage(consumer.root, dep.key);
+          if (absentDevDep(dep) && !actual.file) return false;
           return actual.version !== versions[dep.package] || !placed(actual.file);
         });
         // A link is only a fault when it escapes every legitimate root; a self-contained one is fine.