total-recall-brain 3.46.0 → 3.46.2

package/bin/total-recall.mjs

@@ -275,6 +275,9 @@ async function main() {
       console.error(`Expected handler at: ${handlerPath}`);
       process.exit(1);
     }
+    // A new plugin contract refuses the previous release's defaults, `update` included; refresh them and rerun once.
+    const rerun = await import('../src/core/default-plugin-refresh.mjs').then(m => m.rerunAfterDefaultRefresh(err), () => null);
+    if (rerun !== null) process.exit(rerun);
     console.error(`Error executing '${command}':`, err.message);
     process.exit(1);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "total-recall-brain",
-  "version": "3.46.0",
+  "version": "3.46.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/src/core/dashboard-bundle.mjs

@@ -14,8 +14,10 @@
  * background with the frontend's own build script, and keeps serving the
  * current bundle until the new one is complete. It never installs
  * dependencies: missing build tools are reported, not repaired behind the
- * operator's back. An npm tarball gives every file the same mtime, so an
- * installed package is never stale and never builds.
+ * operator's back. An installed package (a root inside node_modules) serves
+ * the bundle its release built, which the publish gate checked, and is never
+ * stale and never builds: npm does not keep the tarball's file times on every
+ * install, so comparing times there reports a stale bundle that is not.
  */
 import { spawn } from 'node:child_process';
 import fs from 'node:fs';
@@ -60,9 +62,10 @@ export async function newestUnder(target) {
  * Returns { ok, reason, bundle, source }; never throws, never prints, so the
  * decision can be tested apart from how it is reported.
  */
-export async function checkDistFreshness({ distDir, sourcePaths }) {
+export async function checkDistFreshness({ distDir, sourcePaths, packaged = false }) {
   const bundle = await newestUnder(distDir);
   if (!bundle) return { ok: false, reason: 'missing-bundle', bundle: null, source: null };
+  if (packaged) return { ok: true, reason: 'packaged', bundle, source: null };
 
   let source = null;
   for (const candidate of sourcePaths) {
@@ -76,6 +79,11 @@ export async function checkDistFreshness({ distDir, sourcePaths }) {
   return { ok: true, reason: 'current', bundle, source };
 }
 
+/** An npm-installed package: its root sits inside a node_modules directory. */
+export function isInstalledPackage(root) {
+  return path.resolve(root).split(path.sep).includes('node_modules');
+}
+
 /** Every input whose change changes the built dashboard. */
 export function dashboardTargets(root) {
   const frontend = path.join(root, 'frontend');
@@ -85,6 +93,7 @@ export function dashboardTargets(root) {
   } catch { /* no frontend directory: nothing to compare */ }
   return {
     distDir: path.join(frontend, 'dist'),
+    packaged: isInstalledPackage(root),
     sourcePaths: [
       path.join(frontend, 'src'),
       path.join(frontend, 'public'),

package/src/core/default-plugin-refresh.mjs

@@ -0,0 +1,39 @@
+/**
+ * A release that changes the plugin contract refuses the shared default plugins the previous release
+ * installed, and with them every command that loads one, `update` included: the very command that would
+ * replace them. So a machine moving to such a release could not update itself. When a command fails that
+ * way, refresh the defaults from this package's bundled copies (a link is its owner's checkout and is left
+ * alone) and run the command again, once.
+ */
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { ensureRequiredPlugins } from './required-plugins.mjs';
+import { globalPluginsDir } from './plugin-loader.mjs';
+
+const REFUSAL = /\bRequired (?:plugin [\w-]+|[\w-]+ plugin) is missing or invalid\b/;
+export const REFRESHED_ENV = 'TR_DEFAULT_PLUGINS_REFRESHED';
+
+export function isDefaultPluginRefusal(error) {
+  return REFUSAL.test(String(error?.message || ''));
+}
+
+/** Returns the rerun's exit status, or null when this error is not one a refresh can fix. */
+export function rerunAfterDefaultRefresh(error, {
+  env = process.env, argv = process.argv, execPath = process.execPath, ensure = ensureRequiredPlugins,
+  sharedBrainDir = path.dirname(globalPluginsDir()), run = spawnSync, log = (line) => console.error(line),
+} = {}) {
+  if (!isDefaultPluginRefusal(error) || env[REFRESHED_ENV] === '1') return null;
+  try {
+    ensure(sharedBrainDir, { sharedBrainDir });
+  } catch (refreshError) {
+    log(`The default plugins could not be refreshed from this release: ${refreshError.message}`);
+    return null;
+  }
+  log('Refreshed the default plugins from this release; running the command again.');
+  const result = run(execPath, argv.slice(1), { stdio: 'inherit', env: { ...env, [REFRESHED_ENV]: '1' } });
+  if (result.error) {
+    log(`The command could not be run again: ${result.error.message}`);
+    return 1;
+  }
+  return result.status ?? 1;
+}