total-recall-brain 3.44.0 → 3.45.0

package/src/core/access-ledger.mjs

@@ -0,0 +1,78 @@
+/**
+ * Memory access ledger (DECAY-01).
+ *
+ * Records when a memory is actually used: returned by recall or included in a context
+ * capsule. Decay reads it to tell a memory nobody uses from one read every day. It lives in
+ * the brain's derived state, so a read never rewrites a vault file.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { atomicWrite } from './vault.mjs';
+
+const LEDGER = 'access-ledger.json';
+
+function ledgerFile(derivedDir) {
+  return path.join(derivedDir, LEDGER);
+}
+
+/** The ledger as `{ slug: { last_accessed, count } }`. A missing or damaged file is an empty ledger. */
+export function readAccess(derivedDir) {
+  if (!derivedDir) return {};
+  try {
+    const value = JSON.parse(fs.readFileSync(ledgerFile(derivedDir), 'utf8'));
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+  } catch {
+    return {};
+  }
+}
+
+/** Reserved ledger key: the days on which this brain was used at all (YYYY-MM-DD, sorted). */
+export const ACTIVE_DAYS = '_active_days';
+
+/** The days this brain was used, oldest first. */
+export function activeDays(ledger = {}) {
+  return Array.isArray(ledger[ACTIVE_DAYS]) ? ledger[ACTIVE_DAYS] : [];
+}
+
+/**
+ * How many of the brain's active days came after `sinceMs`. Decay counts these, never calendar
+ * days, so a brain nobody works in never decays (Greg, 2026-11-09).
+ */
+export function activeDaysSince(ledger, sinceMs) {
+  const since = new Date(sinceMs).toISOString().slice(0, 10);
+  return activeDays(ledger).filter(day => day > since).length;
+}
+
+/** Record one use of each slug, and today as an active day. Never throws: a failed write must not break recall or preflight. */
+export function recordAccess(derivedDir, slugs, now = new Date()) {
+  const unique = [...new Set((slugs || []).filter(slug => typeof slug === 'string' && slug && slug !== ACTIVE_DAYS))];
+  if (!derivedDir || unique.length === 0) return false;
+  try {
+    const ledger = readAccess(derivedDir);
+    const stamp = now.toISOString();
+    const today = stamp.slice(0, 10);
+    const days = activeDays(ledger);
+    if (!days.includes(today)) ledger[ACTIVE_DAYS] = [...days, today].sort();
+    for (const slug of unique) {
+      const entry = ledger[slug] || { count: 0 };
+      // Three active days are enough for the field's first and second derivatives.
+      const daily = { ...entry.daily_counts, [today]: (Number(entry.daily_counts?.[today]) || 0) + 1 };
+      const recentDays = activeDays(ledger).slice(-3);
+      ledger[slug] = { last_accessed: stamp, count: (Number(entry.count) || 0) + 1,
+        daily_counts: Object.fromEntries(Object.entries(daily).filter(([day]) => recentDays.includes(day))) };
+    }
+    fs.mkdirSync(derivedDir, { recursive: true });
+    atomicWrite(ledgerFile(derivedDir), JSON.stringify(ledger));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** The latest known use of a memory: the ledger, its own `last_accessed`, or its last update. */
+export function lastUsedMs(node, ledger = {}) {
+  const times = [ledger[node.slug]?.last_accessed, node.last_accessed, node.updated, node.created]
+    .map(value => new Date(value || 0).getTime())
+    .filter(Number.isFinite);
+  return times.length ? Math.max(...times) : 0;
+}

package/src/core/agent-manager.mjs

@@ -1,11 +1,11 @@
-/** Compatibility facade; process lifecycle, isolation, metadata and receipts belong to Meta Harness. */
+/** Compatibility facade; process lifecycle, isolation, metadata and receipts belong to Metaharness. */
 import { loadPluginModule } from './plugin-runtime.mjs';
 
 let owner, ownerError;
 try { owner = await loadPluginModule('meta-harness', 'process-manager'); }
 catch (error) { ownerError = error; }
 function implementation() {
-  if (!owner) throw new Error(`Meta Harness processes are unavailable: ${ownerError?.message || 'install the plugin'}`);
+  if (!owner) throw new Error(`Metaharness processes are unavailable: ${ownerError?.message || 'install the plugin'}`);
   return owner;
 }
 export const loadAgentState = (...args) => implementation().loadAgentState(...args);

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

@@ -116,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;
@@ -191,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
@@ -210,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 = [];
@@ -270,12 +280,16 @@ export async function updateAllBrains(opts = {}) {
     const shared = isLink(path.join(owner.owner, 'node_modules')) || isLink(path.join(consumer.root, 'node_modules'));
     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 });
   }
@@ -290,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 });
@@ -322,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}`);
@@ -338,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.
@@ -368,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-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';
@@ -142,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

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. */