total-recall-brain 3.44.0 → 3.45.0

package/src/core/task-executors.mjs

@@ -1,4 +1,3 @@
-import { loadPluginModule as __loadOwnedPlugin } from './plugin-runtime.mjs';
 /**
  * Executor registry for daemon tasks.
  *
@@ -41,43 +40,18 @@ function policyCheck(task) {
 
 async function runDream(task, ctx) {
   const { runDreamCycle } = await import('./dream.mjs');
-  await runDreamCycle({
+  const result = await runDreamCycle({
     vaultDir: ctx.vaultDir,
     skillsDir: ctx.skillsDir,
     derivedDir: ctx.derivedDir,
     conflictsDir: ctx.conflictsDir,
     instructionsFile: ctx.instructionsFile,
+    runtimeConfig: ctx.runtimeConfig,
   });
+  if (result?.status !== 'success') return { success: false, error: result?.errors?.join('; ') || 'unsupported', executor: 'dream' };
   return { success: true, output: 'Dream cycle complete', executor: 'dream' };
 }
 
-async function runSessionIngest(task, ctx) {
-  const { scanAndIngest } = await import('./session-watcher.mjs');
-  const result = scanAndIngest(ctx.sessionsDir);
-  return {
-    success: true,
-    output: `Ingested ${result.ingested} new sessions`,
-    executor: 'session-ingest',
-  };
-}
-
-async function runSurfaceCompile(task, ctx) {
-  const { compileSurface } = await import('./surface.mjs');
-  await compileSurface({
-    vaultDir: ctx.vaultDir,
-    skillsDir: ctx.skillsDir,
-    derivedDir: ctx.derivedDir,
-    instructionsFile: ctx.instructionsFile,
-  });
-  return { success: true, output: 'Surface recompiled', executor: 'surface-compile' };
-}
-
-async function runPrune(task, ctx) {
-  const { autoPruneStorage } = await import('./dream.mjs');
-  autoPruneStorage(ctx.brainDir, ctx.vaultDir, ctx.conflictsDir);
-  return { success: true, output: 'Storage prune complete', executor: 'prune' };
-}
-
 async function runCustom(task, ctx) {
   const land = task.result?.land || 'inbox';
   const intent = task.intent || task.body || task.reason || task.slug;
@@ -89,8 +63,8 @@ async function runCustom(task, ctx) {
       message: `Custom task (log only): ${task.slug} — ${intent}`,
     });
     return {
-      success: true,
-      output: `Custom task recorded (no vault write): ${intent}`.slice(0, 500),
+      success: false,
+      error: 'unsupported',
       executor: 'custom',
     };
   }
@@ -207,7 +181,7 @@ async function runLegacyCategoryDispatch(task, ctx) {
   }
 
   if (category === 'system2-deliberation') {
-    if (process.env.TR_POWER_EXECUTORS !== '1' && !task._research_id) {
+    if (process.env.TR_POWER_EXECUTORS !== '1' && !task._research_id && !(task.created_by === 'automations' && task.payload?.scheduledIdle)) {
       return {
         success: false,
         error: 'system2-deliberation requires TR_POWER_EXECUTORS=1 (or research-queue phase)',
@@ -221,6 +195,7 @@ async function runLegacyCategoryDispatch(task, ctx) {
       inboxDir: path.join(BRAIN_DIR, 'memory-inbox', 'pending'),
       runtimeConfig,
     });
+    if (result.error || result.success === false) return { success: false, error: result.error || 'Inference failed', executor: 'system2' };
     return {
       success: true,
       output: `Inference complete: ${result.conclusions?.length || 0} conclusions`,
@@ -253,7 +228,9 @@ async function runLegacyCategoryDispatch(task, ctx) {
         vaultDir: VAULT_DIR,
         inboxDir: path.join(BRAIN_DIR, 'memory-inbox', 'pending'),
         runtimeConfig,
+        fromTurn: 1,
       });
+      if (result.error) return { success: false, error: result.error, executor: 'post-mortem' };
       return {
         success: true,
         output: `Post-mortem: ${result.nodesCreated || 0} nodes`,
@@ -280,6 +257,7 @@ async function runLegacyCategoryDispatch(task, ctx) {
         inboxDir: path.join(BRAIN_DIR, 'memory-inbox', 'pending'),
         runtimeConfig,
       });
+      if (result.error || result.success === false) return { success: false, error: result.error || 'Clarity review failed', executor: 'clarity' };
       return {
         success: true,
         output: `Clarity review: rewrote=${result.rewrote}`,
@@ -287,17 +265,8 @@ async function runLegacyCategoryDispatch(task, ctx) {
       };
     }
     if (String(task.slug || '').startsWith('memory-compaction-')) {
-      const { runMemoryCompaction } = await import('./fact-seeker.mjs');
-      const result = await runMemoryCompaction({
-        vaultDir: VAULT_DIR,
-        inboxDir: path.join(BRAIN_DIR, 'memory-inbox', 'pending'),
-        runtimeConfig,
-      });
-      return {
-        success: true,
-        output: `Compaction: ${result.consolidatedCount || 0} nodes`,
-        executor: 'compaction',
-      };
+      const { fileCleanupProposals } = await import('./cleanup-task.mjs');
+      return fileCleanupProposals(VAULT_DIR);
     }
     // generic maintenance: lease vacuum
     try {
@@ -324,10 +293,10 @@ async function runLegacyCategoryDispatch(task, ctx) {
     return { success: true, output: 'Maintenance complete', executor: 'maintenance' };
   }
 
-  if (category === 'exploration' || category === 'self-evaluation' || category === 'skill-engineering') {
+  if (category === 'self-evaluation' || category === 'skill-engineering') {
     return {
-      success: true,
-      output: `Acknowledged category ${category} (no-op in core mode)`,
+      success: false,
+      error: 'unsupported',
       executor: category,
     };
   }
@@ -335,7 +304,7 @@ async function runLegacyCategoryDispatch(task, ctx) {
   // Unknown — fail loud
   return {
     success: false,
-    error: `Unknown task executor/category: executor=${task.executor || 'null'} category=${category || 'null'} kind=${task.kind || 'null'} slug=${task.slug}`,
+    error: 'unsupported',
     executor: 'unknown',
   };
 }
@@ -375,7 +344,7 @@ async function runResearchLegacy(task, ctx) {
     // researched — so it is now a no-op (RESEARCH_SYSTEM2).
     const topic = String(task.target || '').trim();
     if (!topic || topic === 'global') {
-      return { success: true, output: 'No research topic on this task — nothing to research.', executor: 'research' };
+      return { success: false, error: 'unsupported', executor: 'research' };
     }
 
     // Prefer deep multi-source research when this came from the research queue
@@ -514,7 +483,7 @@ async function runResearchLegacy(task, ctx) {
       quarantineDir: path.join(BRAIN_DIR, 'memory-inbox', 'quarantine'),
     });
     if (result.skipped) {
-      return { success: true, output: `Conclusion writer: ${result.skipped}`, executor: 'research' };
+      return { success: false, error: 'unsupported', executor: 'research' };
     }
     return {
       success: true,
@@ -525,7 +494,7 @@ async function runResearchLegacy(task, ctx) {
 
   return {
     success: false,
-    error: `No research handler matched slug=${task.slug} category=${task.category}`,
+    error: 'unsupported',
     executor: 'research',
   };
 }
@@ -571,47 +540,39 @@ function findLatestResearchDraftSlug(inboxDir, topic) {
 
 // ─── Registry ───────────────────────────────────────────────────────────────────
 
-async function runSecretsRotationCheck(task, ctx) {
-  const { runSecretsRotationCheck: run } = await __loadOwnedPlugin('auth', 'secrets-rotate');
-  return run(ctx);
-}
-
-async function runSecretsExportEnv(task, ctx) {
-  const { runSecretsExportAll } = await __loadOwnedPlugin('auth', 'secrets-rotate');
-  return runSecretsExportAll(ctx);
+async function runSkillGap(task, ctx) {
+  const { requestSkillGap } = await import('./skill-gap.mjs');
+  const topic = task.payload?.topic || task.target || /topic "([^"]+)"/.exec(task.reason || '')?.[1];
+  const session = task.source_session || task.origin?.session_id;
+  return requestSkillGap(topic, task.payload?.evidence ||
+    (session ? `session://${session}` : null), { projectRoot: ctx.projectRoot || process.cwd() });
 }
 
-async function runSecretsRotationAssist(task, ctx) {
-  // Supervised: ensure prompt is present; does not auto-browser without agent session
-  const key = task.payload?.secret_key || task.slug?.replace(/^secret-rotate-/, '');
-  if (!key) {
-    return { success: false, error: 'missing secret_key', executor: 'secrets-rotation-assist' };
+async function runLessonReview(task, ctx) {
+  const { runPostMortem } = await import('./post-mortem.mjs');
+  const sessionPath = task.payload?.sessionPath || (task.target && path.join(ctx.sessionsDir, task.target));
+  if (!sessionPath) return { success: false, error: 'Lesson review requires a session transcript and turn range' };
+  const result = await runPostMortem(sessionPath, {
+    vaultDir: ctx.vaultDir, inboxDir: path.join(ctx.brainDir, 'memory-inbox', 'pending'), runtimeConfig: ctx.runtimeConfig,
+    // Scheduled snapshots already contain exactly the requested range.
+    fromTurn: task.payload?.sessionPath ? 1 : task.payload?.fromTurn,
+    toTurn: task.payload?.sessionPath ? Infinity : task.payload?.toTurn,
+    sourceRef: task.payload?.sessionId ? `${task.payload.sessionId}/turns/${task.payload.fromTurn}-${task.payload.toTurn}` : task.slug,
+    hold: task.payload?.hold === true,
+  });
+  if (result.error) return { success: false, error: result.error, executor: 'lesson-review' };
+  if (task.slug?.startsWith('lesson-review-')) {
+    const dir = path.join(ctx.brainDir, 'lesson-reviews');
+    fs.mkdirSync(dir, { recursive: true });
+    atomicWrite(path.join(dir, `${task.slug}.done`), new Date().toISOString());
   }
-  const { getBrowserRotateAssist } = await __loadOwnedPlugin('auth', 'secrets-rotate');
-  const assist = await getBrowserRotateAssist(ctx.brainDir, key);
-  return {
-    success: true,
-    output: `Browser rotation assist ready for ${key}. Console: ${assist.console_url || 'n/a'}. Use browser tools with human 2FA; then secret rotate --export-env.`,
-    executor: 'secrets-rotation-assist',
-    assist: {
-      key: assist.key,
-      console_url: assist.console_url,
-      docs_url: assist.docs_url,
-      overdue: assist.overdue,
-      // prompt available to agent; do not echo secrets
-      prompt: assist.prompt,
-    },
-  };
+  return { success: true, output: `Lesson review: ${result.patterns?.length || 0} patterns, ${result.facts?.length || 0} facts, ${result.skill_gaps?.length || 0} skill gaps, ${result.violations?.length || 0} violations`, executor: 'lesson-review' };
 }
 
 const EXECUTORS = {
-  'secrets-rotation-check': { id: 'secrets-rotation-check', run: runSecretsRotationCheck },
-  'secrets-export-env': { id: 'secrets-export-env', run: runSecretsExportEnv },
-  'secrets-rotation-assist': { id: 'secrets-rotation-assist', run: runSecretsRotationAssist },
+  'lesson-review': { id: 'lesson-review', run: runLessonReview },
+  'skill-manager': { id: 'skill-manager', run: runSkillGap },
   dream: { id: 'dream', run: runDream },
-  'session-ingest': { id: 'session-ingest', run: runSessionIngest },
-  'surface-compile': { id: 'surface-compile', run: runSurfaceCompile },
-  prune: { id: 'prune', run: runPrune },
   custom: { id: 'custom', run: runCustom },
   research: { id: 'research', run: runResearchLegacy },
   legacy: { id: 'legacy', run: runLegacyDispatch },
@@ -623,31 +584,16 @@ const EXECUTORS = {
 export function resolveExecutor(task) {
   const t = normalizeTask(task);
 
-  if (t.executor && EXECUTORS[t.executor]) {
-    return EXECUTORS[t.executor];
-  }
+  if (t.category === 'skill-engineering') return EXECUTORS['skill-manager'];
+  if (t.category === 'lesson-review' || t.category === 'self-evaluation') return EXECUTORS['lesson-review'];
+
+  // An explicit unsupported executor must never fall through to kind/category.
+  if (t.executor) return typeof t.executor === 'string' && Object.hasOwn(EXECUTORS, t.executor) ? EXECUTORS[t.executor] : null;
 
   // System / named slugs
   if (t.slug === 'dream' || String(t.slug || '').startsWith('dream-') || t.executor === 'dream') {
     return EXECUTORS.dream;
   }
-  if (String(t.slug || '').startsWith('session-ingest')) return EXECUTORS['session-ingest'];
-  if (String(t.slug || '').startsWith('surface-compile')) return EXECUTORS['surface-compile'];
-  if (String(t.slug || '').startsWith('prune-') || t.slug === 'prune') return EXECUTORS.prune;
-  if (String(t.slug || '').startsWith('secret-rotate-') || t.category === 'secrets-rotation') {
-    return EXECUTORS['secrets-rotation-assist'];
-  }
-  if (String(t.slug || '').startsWith('secrets-rotation-check') || t.executor === 'secrets-rotation-check') {
-    return EXECUTORS['secrets-rotation-check'];
-  }
-  if (String(t.slug || '').startsWith('secrets-export') || t.executor === 'secrets-export-env') {
-    return EXECUTORS['secrets-export-env'];
-  }
-
-  if (t.kind === 'custom' || t.category === 'custom' || t.executor === 'custom') {
-    return EXECUTORS.custom;
-  }
-
   // Known legacy categories still registered
   const legacyCategories = new Set([
     'conscious-enforcement',
@@ -658,13 +604,14 @@ export function resolveExecutor(task) {
     'proactive-research',
     'skill-engineering',
     'self-evaluation',
-    'exploration',
   ]);
 
   if (legacyCategories.has(t.category) || t._research_id || t._is_remote_vault_sync) {
     return EXECUTORS.legacy;
   }
 
+  if (t.category === 'custom' || (t.kind === 'custom' && !t.category)) return EXECUTORS.custom;
+
   if (t.kind === 'research') return EXECUTORS.research;
   if (t.kind === 'system' || t.kind === 'maintenance' || t.kind === 'memory') {
     return EXECUTORS.legacy;
@@ -691,11 +638,12 @@ export async function dispatchTask(task, ctx) {
       `Unknown task executor for slug=${normalized.slug} ` +
       `category=${normalized.category} kind=${normalized.kind} executor=${normalized.executor}`;
     logger.info({ subsystem: 'task-executors', message: msg });
-    return { success: false, error: msg, executor: 'unknown' };
+    return { success: false, error: 'unsupported', executor: 'unknown' };
   }
 
   try {
     const result = await executor.run(normalized, ctx);
+    if (!result || typeof result.success !== 'boolean') return { success: false, error: 'unsupported', executor: executor.id };
     return { ...result, executor: result.executor || executor.id };
   } catch (err) {
     return {

package/src/core/validated-write.mjs

@@ -156,6 +156,7 @@ export async function writeNodeValidatedAsync(node, vaultDir, options = {}) {
     agentRole,
     leaseStore,
     eventLogDir,
+    allowLong: options.allowLong === true,
   });
 
   if (result.success && !dryRun) {