total-recall-brain 3.43.3 → 3.45.0

package/src/core/brain-locate.mjs

@@ -47,6 +47,11 @@ export function detectProjectBrain(startDir = process.cwd()) {
     // sibling in src/cli/agent-dir.mjs checked both, so the two could disagree
     // about whether a project brain exists at all. It is now the single
     // implementation and the sibling delegates here.
+    // The Total Recall package's own `scaffold/` is the template every install copies. It carries
+    // a SKILL.md, so the walk took it for a project: a context call or `project-id` from inside
+    // it wrote brain.json and derived ledgers into the template, which then ships (2026-11-09).
+    // Skip it: the project that contains the package (its checkout or the consumer) is the brain.
+    if (isPackageScaffold(dir)) { dir = path.dirname(dir); continue; }
     for (const name of ['.agent', '.agents']) {
       const candidate = path.join(dir, name, 'skills', 'total-recall');
       if (fs.existsSync(path.join(candidate, 'SKILL.md')) || fs.existsSync(path.join(candidate, 'memory-vault'))) {
@@ -131,3 +136,13 @@ function pluginTargets(pluginsRoot) {
   }
   return targets;
 }
+
+/** True for the Total Recall package's install template: `<package>/scaffold`, in a checkout or in node_modules. */
+export function isPackageScaffold(dir) {
+  if (path.basename(dir) !== 'scaffold') return false;
+  try {
+    return JSON.parse(fs.readFileSync(path.join(path.dirname(dir), 'package.json'), 'utf8')).name === 'total-recall-brain';
+  } catch {
+    return false;
+  }
+}

package/src/core/brain-updates.mjs

@@ -19,6 +19,13 @@ const sections = ['dependencies', 'devDependencies', 'optionalDependencies', 'pe
 const ignored = new Set(['node_modules', 'vendor', 'dist', 'build', 'coverage', 'venv',
   'test', 'tests', '__tests__', 'fixtures', 'tmp', 'scratch', 'scaffold', 'memory-derived']);
 const canonical = key => key === '@ssss/cli' ? '@gregiteen/ssss-cli' : key;
+// Plugins also force the engine alias through `overrides`. Those pins move with the dependency,
+// or a consumer ends up asking for two versions of the same package.
+const overrideKeys = pkg => Object.entries(pkg.overrides || {})
+  .filter(([key, spec]) => typeof spec === 'string' && BRAIN_PACKAGES.includes(canonical(key)) && canonical(key) !== pkg.name)
+  .map(([key]) => key);
+const overridesLag = (pkg, versions) => overrideKeys(pkg)
+  .some(key => versions[canonical(key)] && pkg.overrides[key] !== targetSpec(key, versions[canonical(key)]));
 const read = file => JSON.parse(fs.readFileSync(file, 'utf8'));
 const isLink = file => { try { return fs.lstatSync(file).isSymbolicLink(); } catch { return false; } };
 export const brainUpdateLockPath = owner => path.join(os.tmpdir(),
@@ -109,7 +116,11 @@ export function discoverBrainConsumers(roots, { onError, installedPlugins = new
         .filter(([key]) => BRAIN_PACKAGES.includes(canonical(key)) && canonical(key) !== pkg.name)
         .map(([key, declared]) => ({ section, key, package: canonical(key), declared,
           ...installedBrainPackage(real, key) })));
-      if (deps.length) consumers.push({ root: real, file, pkg, deps, runtimeOnly });
+      // A source checkout of a brain package is not a consumer: its pins move only
+      // with its own releases (updateSourceBrainPackage). Rewriting them left the
+      // cloud server's checkout dirty, and the release runner refuses a dirty one.
+      const brainSource = BRAIN_PACKAGES.includes(pkg.name);
+      if (deps.length && !brainSource) consumers.push({ root: real, file, pkg, deps, runtimeOnly });
     }
     for (const entry of fs.readdirSync(real, { withFileTypes: true })) {
       if (!entry.isDirectory() || ignored.has(entry.name)) continue;
@@ -184,13 +195,18 @@ function targetSpec(key, version) {
   return key === '@ssss/cli' ? `npm:@gregiteen/ssss-cli@${version}` : 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.
+ * Automatic maintenance keeps each checkout's tree as found. A dependency with no installed
+ * copy, in a checkout (and owner) with no node_modules at all, gets its pin updated and nothing
+ * more: the tree was reclaimed for disk space or never installed, and restoring it is the
+ * owner's call. A dev dependency absent from a shared install is the same case. Without this,
+ * every hourly run reinstalled full trees into idle checkouts (~10 GB on 2026-11-07, again on
+ * 2026-11-09 until the disk filled). `installMissing: true` (CLI --install-missing) opts in.
  */
 const absentDevDep = (dep) => dep.section === 'devDependencies' && !dep.file;
+const noInstallTree = (...roots) => roots.every(root => !fs.existsSync(path.join(root, 'node_modules')));
+const keepAsFound = (dep, installMissing, ...roots) =>
+  !installMissing && !dep.file && (absentDevDep(dep) || noInstallTree(...roots));
 
 /**
  * The daemon runs with NODE_ENV=production, and under that npm and pnpm remove dev dependencies
@@ -203,6 +219,7 @@ export function installEnv(env = process.env) {
 
 export async function updateAllBrains(opts = {}) {
   const dryRun = opts.dryRun !== false;
+  const installMissing = opts.installMissing === true;
   const exec = opts.exec || spawnSync;
   const roots = listUpdateRoots(opts).map(row => row.root);
   const errors = [];
@@ -261,14 +278,18 @@ 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 => {
+    const needsChange = shared || (!consumer.runtimeOnly && overridesLag(consumer.pkg, versions)) || consumer.deps.some(dep => {
       const pinLags = !consumer.runtimeOnly && dep.declared !== targetSpec(dep.key, versions[dep.package]);
-      if (absentDevDep(dep)) return pinLags;
+      if (keepAsFound(dep, installMissing, consumer.root, owner.owner)) 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 (!needsChange) {
+      // Kept as found: report the missing tree, install nothing.
+      if (consumer.deps.some(dep => !dep.version)) row.status = 'not_installed';
+      continue;
+    }
+    row.status = dryRun ? (consumer.deps.some(dep => !dep.version) ? 'not_installed' : 'would_update') : 'pending';
     if (!groups.has(owner.owner)) groups.set(owner.owner, { ...owner, consumers: [] });
     groups.get(owner.owner).consumers.push({ consumer, row });
   }
@@ -283,7 +304,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 => !absentDevDep(dep)
+      isLink(path.join(consumer.root, 'node_modules')) || consumer.deps.some(dep =>
+        !keepAsFound(dep, installMissing, consumer.root, group.owner)
         && (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 });
@@ -296,6 +318,9 @@ export async function updateAllBrains(opts = {}) {
         saved.set(consumer.file, text);
         const pkg = read(consumer.file);
         for (const dep of consumer.deps) pkg[dep.section][dep.key] = targetSpec(dep.key, versions[dep.package]);
+        for (const key of overrideKeys(pkg)) {
+          if (versions[canonical(key)]) pkg.overrides[key] = targetSpec(key, versions[canonical(key)]);
+        }
         const indent = /\n([ \t]+)"/.exec(text)?.[1] || 2;
         fs.writeFileSync(consumer.file, JSON.stringify(pkg, null, indent) + '\n');
       }
@@ -312,7 +337,10 @@ export async function updateAllBrains(opts = {}) {
       if (runtimeOnly) args.push(group.manager === 'pnpm' ? '--prod' : '--omit=dev');
       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');
+      // A lockfile-only update builds no tree, so it runs no lifecycle scripts: npm still
+      // ran a checkout's own postinstall here, which fails in a repository that was never
+      // installed (a postinstall calling a tool that is not yet installed, 2026-11-09).
+      else if (!needsInstall) args.push(group.manager === 'pnpm' ? '--lockfile-only' : '--package-lock-only', '--ignore-scripts');
       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}`);
@@ -328,7 +356,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;
+          if (keepAsFound(dep, installMissing, consumer.root, group.owner) && !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.
@@ -358,5 +386,7 @@ export async function updateAllBrains(opts = {}) {
     updated: results.filter(row => row.status === 'updated').length,
     shared_install: results.filter(row => row.status === 'shared_install').length,
     would_update: results.filter(row => row.status === 'would_update').length,
+    not_installed: results.filter(row => row.status === 'not_installed').length,
+    up_to_date: results.filter(row => row.status === 'up_to_date').length,
     failed: results.filter(row => row.status === 'failed').length, results };
 }

package/src/core/claude-hooks.mjs

@@ -12,6 +12,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { installLessonHooks } from './lesson-hooks.mjs';
 
 const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
 export const GATE_TEMPLATE = path.join(PACKAGE_ROOT, 'templates', 'claude-hooks', 'total-recall-gate.mjs');
@@ -104,5 +105,6 @@ export function installClaudeCodeHooks(opts = {}) {
     if (fs.existsSync(settingsPath)) fs.copyFileSync(settingsPath, `${settingsPath}.bak-total-recall`);
     fs.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
   }
-  return { gate: hookPath, settings: settingsPath, added, removed };
+  const lessons = installLessonHooks({ harness: 'claude', settings: settingsPath, status: 'installed' }, { dryRun: opts.dryRun });
+  return { gate: hookPath, settings: settingsPath, added, removed, lessons };
 }

package/src/core/cleanup-task.mjs

@@ -0,0 +1,15 @@
+import { generateMemoryCleanupProposals, dedupeProposals, evaluateProposalGate } from './optimizer.mjs';
+import { writeNode } from './vault.mjs';
+
+/** Compaction uses the same gate, identity and review path as dream cleanup. */
+export async function fileCleanupProposals(vaultDir, { generate = generateMemoryCleanupProposals,
+  dedupe = dedupeProposals, gate = evaluateProposalGate, write = writeNode } = {}) {
+  const { kept, suppressed } = dedupe(await generate(vaultDir), vaultDir);
+  let persisted = 0;
+  for (const proposal of kept) {
+    await gate(proposal, null, vaultDir);
+    await write(proposal, vaultDir);
+    persisted++;
+  }
+  return { success: true, persisted, suppressed, output: `Compaction filed ${persisted} cleanup proposals`, executor: 'compaction' };
+}

package/src/core/cli-commands.mjs

@@ -5,10 +5,12 @@ export const CLI_COMMANDS = {
   setup:    'setup.mjs',
   start:    'start.mjs',
   startup:  'startup.mjs',
+  server:   'server.mjs',
   deploy:   'deploy.mjs',
   doctor:   'doctor.mjs',
   backup:   'backup.mjs',
   dream:    'dream.mjs',
+  lessons:  'lessons.mjs',
   lint:     'lint.mjs',
   daemon:   'daemon.mjs',
   restore:  'restore.mjs',

package/src/core/cli-maintenance.mjs

@@ -21,7 +21,10 @@ export function cliInputFingerprint(root) {
 
 export async function maintainCliSurfaces({brainDir,brains,force=false,run=runBounded,fingerprint=cliInputFingerprint}={}) {
   const results=[];
-  for(const brain of brains || listLocalBrains({globalBrainDir:brainDir})) {
+  // By default only the global brain: entry files are static and each repository reads its
+  // rules and commands on demand, so the daemon never fans a refresh out across registered
+  // repositories (ON-DEMAND-CONTEXT-01). An explicit brain list is still honoured.
+  for(const brain of brains || listLocalBrains({globalBrainDir:brainDir}).filter(item=>item.kind==='global')) {
     if(!brain.exists || brain.enabled===false)continue;
     const root=brain.root || path.dirname(path.dirname(brain.brainDir));
     const file=path.join(brain.brainDir,'memory-derived/cli-maintenance.json');

package/src/core/cli-semantic-index.mjs

@@ -22,6 +22,21 @@ import { logger } from './logger.mjs';
 import { atomicWrite } from './vault.mjs';
 import { globalAgentDir } from './local-config.mjs';
 
+/** Usage text for declared plugin arguments: positional as <label>, flags as [--flag <label>] or [--flag]. */
+export function formatSubcommandArgs(args) {
+  if (typeof args === 'string') return args ? ` ${args}` : '';
+  if (!Array.isArray(args)) return '';
+  const parts = [];
+  for (const arg of args) {
+    if (!arg || typeof arg !== 'object') continue;
+    const label = String(arg.name || arg.label || 'value').replace(/\s+/g, '-');
+    if (arg.positional || !arg.flag) parts.push(arg.required ? `<${label}>` : `[${label}]`);
+    else if (arg.type === 'boolean') parts.push(arg.required ? arg.flag : `[${arg.flag}]`);
+    else parts.push(arg.required ? `${arg.flag} <${label}>` : `[${arg.flag} <${label}>]`);
+  }
+  return parts.length ? ` ${parts.join(' ')}` : '';
+}
+
 /** Canonical descriptions and usage signatures for built-in core commands. */
 const CORE_METADATA = {
   app: {
@@ -49,6 +64,11 @@ const CORE_METADATA = {
     usage: 'total-recall startup [check|ensure]',
     effect: 'write'
   },
+  server: {
+    description: 'Repair and verify the macOS server LaunchAgent for this package.',
+    usage: 'total-recall server ensure [--dry-run]',
+    effect: 'write'
+  },
   deploy: {
     description: 'Deploy host runtime layers, daemon services, or launch browser setup.',
     usage: 'total-recall deploy [--ui]',
@@ -66,7 +86,7 @@ const CORE_METADATA = {
   },
   dream: {
     description: 'Trigger memory consolidation sleep cycle.',
-    usage: 'total-recall dream',
+    usage: 'total-recall dream [--all-brains] [--dry-run] [--json]',
     effect: 'write'
   },
   lint: {
@@ -320,7 +340,7 @@ const CORE_METADATA = {
     effect: 'read'
   },
   harness: {
-    description: 'Meta-harness orchestration, task dispatch, and council consensus.',
+    description: 'Metaharness orchestration, task dispatch, and council consensus.',
     usage: 'total-recall harness [dispatch|council|usage]',
     effect: 'write'
   },
@@ -431,7 +451,7 @@ export function harvestAllCliVerbs({ projectRoot = process.cwd(), skillsDir = nu
         if (seenIds.has(subId)) continue;
         seenIds.add(subId);
 
-        const argsStr = sub.args ? ` ${sub.args}` : '';
+        const argsStr = formatSubcommandArgs(sub.args);
         verbs.push({
           id: subId,
           name: sub.name,

package/src/core/context-compactor.mjs

@@ -62,6 +62,9 @@ export function compactRules(items, { budget, expand = [], header, complete = fa
   if (unknown.length) throw new Error(`Cannot expand rules not in this capsule: ${unknown.join(', ')}`);
   const duplicateOf = findDuplicates(ranked.filter(item => !expand.includes(item.slug)));
   const tiers = new Map(ranked.map(item => [item.slug, 'omitted']));
+  const isEvidence = item => item.taskEvidence && !item.required;
+  const supplement = supplemental.filter(item => item.text && !isEvidence(item)).map(item => item.text.trim());
+  const evidence = supplemental.filter(item => item.text && isEvidence(item)).map(item => item.text.trim()).join('\n\n---\n\n');
 
   const render = () => {
     const of = tier => ranked.filter(item => tiers.get(item.slug) === tier);
@@ -71,10 +74,11 @@ export function compactRules(items, { budget, expand = [], header, complete = fa
     const blocks = [
       ...full.map(item => item.text.trim()),
       ...summary.map(item => `[${item.slug}] ${summarizeRule(item.body)}`),
-      ...supplemental.filter(item => item.text).map(item => item.text.trim()),
+      ...supplement,
     ];
     if (reference.length) blocks.push(`Referenced: ${reference.map(item => item.slug).join(', ')}`);
     if (duplicate.length) blocks.push(`Duplicates: ${duplicate.map(item => `${item.slug} (of ${duplicateOf.get(item.slug)})`).join(', ')}`);
+    if (evidence) blocks.push(evidence);
     const body = blocks.join('\n\n---\n\n');
     // The token count sits inside the text it counts, so iterate to a stable value.
     let tokens = estimateTokens(body);
@@ -142,5 +146,6 @@ export function compactRules(items, { budget, expand = [], header, complete = fa
   for (const slug of duplicateOf.keys()) tryTier(ranked.find(item => item.slug === slug), 'duplicate');
 
   const { context, counts, tokens } = render();
-  return { context, counts, tokens, tiers: Object.fromEntries(tiers) };
+  return { context, counts, tokens, tiers: Object.fromEntries(tiers),
+    ...(evidence && { evidenceStart: context.length - evidence.length }) };
 }

package/src/core/context-compiler.mjs

@@ -1,6 +1,9 @@
 /** Local task capsules: explicit required rules, ranked supporting knowledge, complete-render accounting. */
 
+import path from 'node:path';
 import { getNodes } from './vault-cache.mjs';
+import { recordAccess } from './access-ledger.mjs';
+import { brainDir as globalBrainDir } from './local-config.mjs';
 import crypto from 'node:crypto';
 import { selectRules, assembleContext, curatedRules, ruleFingerprint, RULE_CATEGORIES } from './context-policy.mjs';
 import { retrieveTaskKnowledge, summarizeRetrieval } from './task-context.mjs';
@@ -109,7 +112,10 @@ export async function compileContext({
   }
 
   const cliContributions = cliVerbContribution ? [cliVerbContribution] : [];
-  const supporting = [...knowledge.contributions, ...cliContributions];
+  const evidence = knowledge.summary.selected
+    ? knowledge.contributions.map(item => ({ ...item, taskEvidence: true }))
+    : knowledge.contributions;
+  const supporting = [...evidence, ...cliContributions];
   const result = assembleContext([...required, ...supporting, ...contributions], { total: b.total });
   const evidenceMissing = supporting.some(item => !result.stats.contributions.some(placed => placed.id === item.id));
   // Compaction may reclaim rule explanation space; never claim readiness after losing selected task evidence.
@@ -139,9 +145,26 @@ export async function compileContext({
   result.stats.slots = { invariants: { nodes: rules.filter(n => n.category === 'invariants').length,
     tokens: result.stats.required_tokens } };
   result.stats.slots_filled = result.stats.contributions.length;
+  // DECAY-01: a capsule is a real use of the rules and memories it carries.
+  recordCapsuleAccess(derivedDir, rules, knowledge.contributions);
   return result;
 }
 
+/**
+ * Record each rule and memory a capsule carries in the ledger of the brain that owns it, so
+ * decay in the global brain sees global rules used by every project.
+ */
+export function recordCapsuleAccess(derivedDir, rules = [], contributions = [], globalDerivedDir = path.join(globalBrainDir, 'memory-derived')) {
+  const owned = { project: [], global: [] };
+  for (const node of rules) (node._layer === 'global' ? owned.global : owned.project).push(node.slug);
+  for (const { id } of contributions || []) {
+    const match = /^vault:(global|project):(.+)$/.exec(String(id || ''));
+    if (match) owned[match[1]].push(match[2]);
+  }
+  if (derivedDir) recordAccess(derivedDir, owned.project);
+  recordAccess(derivedDir && path.resolve(derivedDir) === path.resolve(globalDerivedDir) ? derivedDir : globalDerivedDir, owned.global);
+}
+
 /**
  * Second line of every text capsule, so output that is truncated or piped through
  * `head` still carries the rule (the rule once sat at line 544 of the output and
@@ -163,6 +186,8 @@ export function capsuleResponse(result, { total = 4000, debug = false, format =
     retrieval: summarizeRetrieval(result.stats.retrieval),
   };
   const response = { ready: result.ready, context: result.context, stats };
+  // This offset refers to the decoded context string, not the escaped JSON bytes.
+  if (result.evidenceStart !== undefined) response.evidence_start = result.evidenceStart;
   stats.budget = total;
   // Counts affect serialization themselves. Iterate to a stable representation.
   for (let i = 0; i < 20; i++) {

package/src/core/context-policy.mjs

@@ -100,14 +100,18 @@ export function assembleContext(contributions, { total = 4000 } = {}) {
     if (estimateTokens(render([...selected, item])) <= total) selected.push(item);
     else excluded.push(item.id);
   }
-  const context = render(selected);
+  const isEvidence = item => item.taskEvidence && !item.required;
+  const evidence = selected.filter(isEvidence);
+  const ordered = [...selected.filter(item => !isEvidence(item)), ...evidence];
+  const context = render(ordered);
+  const evidenceText = render(evidence);
   const totalTokens = estimateTokens(context);
-  return { context, ready: requiredTokens <= total, stats: {
+  return { context, ...(evidenceText && { evidenceStart: context.length - evidenceText.length }), ready: requiredTokens <= total, stats: {
     token_measurement: 'estimated_chars_divided_by_four', total_tokens: totalTokens,
     budget_used: totalTokens, budget_remaining: Math.max(0, total - totalTokens),
     required_tokens: requiredTokens, overflow_tokens: Math.max(0, requiredTokens - total),
     required_ids: required.map(c => c.id), excluded_ids: excluded,
-    contributions: selected.map(c => ({ id: c.id, required: Boolean(c.required), chars: c.text.length, estimated_tokens: estimateTokens(c.text) })),
+    contributions: ordered.map(c => ({ id: c.id, required: Boolean(c.required), chars: c.text.length, estimated_tokens: estimateTokens(c.text) })),
     version: crypto.createHash('sha256').update(JSON.stringify({ total, contributions })).digest('hex'),
   } };
 }

package/src/core/daemon-control.mjs

@@ -37,6 +37,28 @@ export function getDaemonStatus() {
   return status === 'not-started' ? 'not_started' : status === 'stopped' ? 'dead' : status;
 }
 
+/**
+ * Remove the lock of a daemon that is gone, for a server told to run none.
+ *
+ * startDaemon is the only other thing that recovers this lock, and such a server never
+ * calls it. A daemon that went down with the machine left a lock nothing would ever
+ * clear, so the server reported `dead` and `degraded` for good. Only a lock whose process
+ * is verified gone is removed: a live process or one that cannot be identified keeps it.
+ * @returns {boolean} True if a lock was removed.
+ */
+export function clearStaleDaemonLock({ observe = getDaemonObservation } = {}) {
+  try {
+    const before = fs.readFileSync(PID_FILE, 'utf8');
+    if (observe().status !== 'stopped') return false;
+    if (fs.readFileSync(PID_FILE, 'utf8') !== before) return false;
+    fs.unlinkSync(PID_FILE);
+    logger.info('daemon-control', `Removed the lock of daemon PID ${before.trim()}, which is gone. This server runs no daemon.`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Detaches the daemon script in the background and writes its PID to file.
  * @returns {number} The PID of the newly spawned daemon.

package/src/core/daemon-loop.mjs

@@ -4,8 +4,8 @@ import { loadPluginModule as __loadOwnedPlugin } from './plugin-runtime.mjs';
  *
  * Durable worker over the open task envelope queue.
  * - Dispatches via executor registry (fail-loud on unknown)
- * - Does NOT invent idle work unless TR_IDLE_TASKS=1
- * - Periodically runs dream (system memory consolidation)
+ * - Automations owns scheduled maintenance; empty queues stay empty
+ * - Executes dream tasks scheduled by the automations plugin
  * - Ingests sessions on boot; recompiles surfaces every N ticks
  * - Auto-syncs all .md files from registered repos into Total Recall
  *
@@ -17,7 +17,7 @@ import { DAEMON_PID_FILE } from './daemon-control.mjs';
 import fs from 'fs';
 import { fileURLToPath } from 'node:url';
 import { readProcessCommand, entryPathHint, shouldHonorPidLock } from './pid-lock.mjs';
-import { createScheduler, updateTaskStatus, persistTaskToDisk } from './scheduler.mjs';
+import { createScheduler, updateTaskStatus } from './scheduler.mjs';
 import { scanAndIngest } from './session-watcher.mjs';
 import { syncAllRepos } from './repo-sync.mjs';
 import { refreshProviderUsage } from './usage-fetcher.mjs';
@@ -26,7 +26,7 @@ import { updateQueueItem } from './research-queue.mjs';
 import { agentDir, brainDir, detectProjectBrain } from './config.mjs';
 import { runCrons } from './crons.mjs';
 import { dispatchTask as registryDispatch } from './task-executors.mjs';
-import { buildTaskEnvelope, publishTaskSchedulerProtocol } from './task-envelope.mjs';
+import { publishTaskSchedulerProtocol } from './task-envelope.mjs';
 
 const AGENT_DIR = agentDir;
 const BRAIN_DIR = brainDir;
@@ -61,8 +61,16 @@ const RECOMPILE_EVERY_N_TASKS = 20;
 const TASK_SLEEP_MS = 10000;
 const EMPTY_SLEEP_MS = 30000;
 
-// Run a system dream every N empty ticks (memory consolidation without busy-work)
-const DREAM_EVERY_N_EMPTY = 20;
+/** An empty queue only sleeps. Plugin services own recurring task creation. */
+export async function nextDaemonTask(scheduler, { localOnly = false, sleep = ms => new Promise(resolve => setTimeout(resolve, ms)) } = {}) {
+  const next = scheduler.next({ localOnly });
+  if (!next.task) {
+    const sleepMs = localOnly ? TASK_SLEEP_MS : EMPTY_SLEEP_MS;
+    logger.info({ subsystem: 'daemon-loop', message: `Queue empty — sleeping ${sleepMs}ms` });
+    await sleep(sleepMs);
+  }
+  return next;
+}
 
 function executorContext(runtimeConfig) {
   return {
@@ -242,6 +250,7 @@ let running = true;
 let vaultWatcher = null;
 let shuttingDown = false;
 let schedulerProtocolActive = false;
+let lastLessonScan = 0;
 
 // Upper bound on a graceful stop. A loop iteration can be mid-task, so the
 // signal cannot exit instantly — but it must exit *eventually*.
@@ -259,7 +268,7 @@ import { releaseLease } from './leader-election.mjs';
  * daemon.log across three separate SIGTERMs. The fallback timer bounds that, so
  * even a wedged iteration cannot keep the daemon alive indefinitely.
  */
-let stopPluginTasks = null;
+let stopPluginServices = null;
 let stopCliMaintenance = null;
 let stopAutomaticUpdates = null;
 
@@ -269,7 +278,7 @@ function shutdown(signal) {
   logger.info({ subsystem: 'daemon-loop', message: `${signal} received — shutting down gracefully` });
   running = false;
   if (vaultWatcher) vaultWatcher.stop();
-  if (stopPluginTasks) stopPluginTasks();
+  if (stopPluginServices) stopPluginServices();
   stopCliMaintenance?.();
   stopAutomaticUpdates?.();
 
@@ -451,15 +460,16 @@ async function main() {
     }
   }
 
-  let emptyTicks = 0;
 
-  // Plugin tasks are per node (a plugin installed here runs here), so they are
-  // scheduled on their own timer rather than inside the leader-only task loop.
+  // Per-node services owned by plugins (scheduled plugin tasks belong to
+  // automations) start here; core runs whatever active plugins declare.
   try {
-    const { startPluginTaskScheduler } = await import('./plugin-tasks.mjs');
-    stopPluginTasks = startPluginTaskScheduler();
+    const { startPluginDaemonServices } = await import('./plugin-runtime.mjs');
+    const services = await startPluginDaemonServices();
+    stopPluginServices = services.stop;
+    logger.info('daemon-loop', `Plugin daemon services started: ${services.started.join(', ') || 'none'}${services.failed.length ? `; failed: ${services.failed.join(', ')}` : ''}`);
   } catch (err) {
-    logger.warn('daemon-loop', `Plugin task scheduler failed to start: ${err.message}`);
+    logger.warn('daemon-loop', `Plugin daemon services failed to start: ${err.message}`);
   }
 
   while (running) {
@@ -560,14 +570,20 @@ async function main() {
         }
       }
 
-      if (!await isLeader()) {
-        await new Promise(r => setTimeout(r, TASK_SLEEP_MS));
-        taskCount++;
-        continue;
+      const localOnly = !await isLeader();
+
+      // Local transcripts stay on their node. Followers also queue and run reviews.
+      if (Date.now() - lastLessonScan >= 60_000) {
+        lastLessonScan = Date.now();
+        try {
+          scanAndIngest(SESSIONS_DIR);
+          const { enqueueSessionReviews } = await import('./lessons.mjs');
+          enqueueSessionReviews({ brainDir: BRAIN_DIR });
+        } catch (error) { logger.warn('daemon-loop', `Local lesson ingest failed: ${error.message}`); }
       }
 
       // Periodically recompile surfaces (LEADER ONLY)
-      if (taskCount > 0 && taskCount % RECOMPILE_EVERY_N_TASKS === 0) {
+      if (!localOnly && taskCount > 0 && taskCount % RECOMPILE_EVERY_N_TASKS === 0) {
         logger.info({ subsystem: 'daemon-loop', message: 'Running scheduled surface recompile...' });
         try {
           const { compileSurface } = await import('./surface.mjs');
@@ -581,16 +597,6 @@ async function main() {
           logger.info({ subsystem: 'daemon-loop', message: `Surface recompile error: ${err.message}` });
         }
 
-        try {
-          const { compactAppendLogs } = await import('./append-log.mjs');
-          const compactResult = compactAppendLogs();
-          if (compactResult.logs_compacted > 0) {
-            logger.info({ subsystem: 'daemon-loop', message: `Compacted ${compactResult.logs_compacted} append logs (${compactResult.total_entries} entries)` });
-          }
-        } catch (err) {
-          logger.info({ subsystem: 'daemon-loop', message: `Append log compaction error: ${err.message}` });
-        }
-
         try {
           await runCrons({ vaultDir: VAULT_DIR, skillsDir: SKILLS_DIR, brainDir: BRAIN_DIR });
         } catch (err) {
@@ -627,42 +633,13 @@ async function main() {
         queueDir: QUEUE_DIR,
         vaultDir: VAULT_DIR,
         sessionsDir: SESSIONS_DIR,
+        localOnly,
       });
 
-      let { task, source } = scheduler.next();
-
-      // Empty queue: optional system dream, then sleep (no busy-work invention)
+      const { task, source } = await nextDaemonTask(scheduler, { localOnly });
       if (!task) {
-        emptyTicks++;
-        if (emptyTicks % DREAM_EVERY_N_EMPTY === 0) {
-          const dreamEnv = buildTaskEnvelope({
-            intent: 'Scheduled system dream cycle',
-            slug: `dream-system-${Date.now().toString(36)}`,
-            kind: 'system',
-            executor: 'dream',
-            category: 'memory-maintenance',
-            priority: 70,
-            system: true,
-            origin: { agent: 'daemon', created_by: 'daemon-system' },
-            capabilities: ['vault:read', 'vault:write'],
-          });
-          persistTaskToDisk(dreamEnv, QUEUE_DIR);
-          task = dreamEnv;
-          source = 'system';
-          logger.info({
-            subsystem: 'daemon-loop',
-            message: `Empty queue → enqueue system dream (${emptyTicks} empty ticks)`,
-          });
-        } else {
-          logger.info({
-            subsystem: 'daemon-loop',
-            message: `Queue empty (tick ${emptyTicks}) — sleeping ${EMPTY_SLEEP_MS}ms`,
-          });
-          await new Promise((r) => setTimeout(r, EMPTY_SLEEP_MS));
-          continue;
-        }
-      } else {
-        emptyTicks = 0;
+        if (localOnly) taskCount++;
+        continue;
       }
 
       taskCount++;

package/src/core/default-plugins.mjs

@@ -1,7 +1,7 @@
 /** Default runtime foundation and routine agent-development tools. */
 export const DEFAULT_PLUGIN_IDS = Object.freeze([
   'auth', 'ssss', 'mesh', 'openwiki', 'composable-cli', 'meta-harness',
-  'code-quality', 'security', 'embeddings', 'git-sentinel',
+  'code-quality', 'security', 'embeddings', 'git', 'automations',
 ]);
 
 /** Required defaults that own additional installation payloads. */