create-walle 0.9.21 → 0.9.23

package/template/claude-task-manager/lib/session-jobs.js

@@ -18,8 +18,12 @@ const { verifyCandidateForTab, readFirstUserMessage, wordOverlap } = require('./
 const { verifyLineage } = require('./session-lineage.js');
 const claudeDesktopSessions = require('./claude-desktop-sessions');
 const { detectAgentType, normalizeAgentType } = require('./agent-capabilities');
-const { resolveRestoreArgsFromAgentSessions } = require('./session-restore');
+const {
+  resolveRestoreArgsFromAgentSessions,
+  resolveRestoreCwdFromAgentSession,
+} = require('./session-restore');
 const { findCodexSessionFilesByFilename } = require('./session-history');
+const { runSync } = require('./perf-tracker');
 
 const HOSTNAME = os.hostname();
 const fsp = fs.promises;
@@ -58,6 +62,26 @@ function statFileIfReadable(filePath) {
   }
 }
 
+// Short-TTL readdir cache: the session-relink scan readdir's a Claude project dir per STALE
+// session, so multiple stale sessions sharing a project dir each re-listed it within one tick.
+// Coalesce those (1.5s TTL) to one readdirSync per dir per scan. Project-dir contents change
+// slowly (a new JSONL appears on /resume), so a brief TTL is safe.
+const _relinkReaddirCache = new Map(); // dir -> { at, files }
+const _RELINK_READDIR_TTL_MS = Math.max(0, Number(process.env.CTM_RELINK_READDIR_TTL_MS) || 1500);
+function _cachedRelinkReaddir(dir) {
+  const now = Date.now();
+  if (_RELINK_READDIR_TTL_MS > 0) {
+    const hit = _relinkReaddirCache.get(dir);
+    if (hit && (now - hit.at) < _RELINK_READDIR_TTL_MS) return hit.files;
+  }
+  const files = fs.readdirSync(dir);
+  if (_RELINK_READDIR_TTL_MS > 0) {
+    _relinkReaddirCache.set(dir, { at: now, files });
+    if (_relinkReaddirCache.size > 256) _relinkReaddirCache.delete(_relinkReaddirCache.keys().next().value);
+  }
+  return files;
+}
+
 function nextCursorAfterBatch(start, batchLength, totalRows, deletedRows = 0) {
   if (batchLength <= 0 || start + batchLength >= totalRows) return 0;
   return Math.max(0, start + batchLength - Math.max(0, deletedRows));
@@ -82,6 +106,48 @@ function resolveAgentSessionJsonlInfo(row, opts = {}) {
   return null;
 }
 
+// Same resolution as resolveAgentSessionJsonlInfo, but the primary-path stat comes from a
+// pre-computed off-thread `statFiles` result (Map<statPath,{exists,size,mtimeMs}>) instead of a
+// synchronous fs.statSync on the main loop. Only the rare codex readdir fallback (primary path
+// missing on a codex row) drops to main. The synthetic stat carries the {size, mtime} the caller
+// reads (mtime is a Date so `.toISOString()` matches the live-stat path).
+function resolveJsonlInfoFromStatMap(row, statMap) {
+  const storedPath = row?.jsonl_path || '';
+  const statPath = claudeDesktopSessions.sourcePathForStat(storedPath);
+  const st = statPath ? statMap.get(statPath) : null;
+  if (st && st.exists) {
+    return { filePath: storedPath, stat: { size: st.size, mtime: new Date(st.mtimeMs) } };
+  }
+  const provider = normalizeAgentType(row?.provider || '') || row?.provider || '';
+  if (provider === 'codex' && row?.agent_session_id) {
+    // Primary path absent on a codex row → the only alternate location is a readdir scan; do it
+    // on main (rare). Skip the redundant primary statSync we already know missed.
+    return resolveAgentSessionJsonlInfo(row);
+  }
+  return null; // non-codex miss → no file (matches resolveAgentSessionJsonlInfo → null)
+}
+
+function parsedThreadLineage(parsed = {}) {
+  return {
+    threadSource: String(parsed.threadSource || parsed.thread_source || '').trim().toLowerCase(),
+    parentAgentSessionId: String(
+      parsed.parentAgentSessionId
+      || parsed.parent_agent_session_id
+      || parsed.parentThreadId
+      || parsed.parent_thread_id
+      || ''
+    ).trim(),
+    agentNickname: String(parsed.agentNickname || parsed.agent_nickname || '').trim(),
+    agentRole: String(parsed.agentRole || parsed.agent_role || '').trim(),
+  };
+}
+
+function isProviderChildParsedSession(parsed = {}) {
+  if (normalizeAgentType(parsed.agent || parsed.provider || '') !== 'codex') return false;
+  const lineage = parsedThreadLineage(parsed);
+  return lineage.threadSource === 'subagent' && !!lineage.parentAgentSessionId;
+}
+
 /**
  * Register all session-related scheduler jobs.
  * @param {import('./scheduler').Scheduler} scheduler
@@ -108,7 +174,9 @@ function registerSessionJobs(scheduler, deps) {
     runAutoTitleGeneration, healStartupTaskSessionIds,
     sessionIntegrity, getAllSessionFiles, telemetry,
     syncCodingSessionModels,
-    isRestoreInProgress, getServerStartedAt,
+    statFilesOffThread,
+    isRestoreInProgress, getServerStartedAt, getRestoreCompletedAt, isDbWarming, isDbWorkerDegraded,
+    getLastUserInteractiveInputAt,
   } = deps;
 
   // Grace window for session-relink: the job is disabled during startup restore
@@ -118,6 +186,7 @@ function registerSessionJobs(scheduler, deps) {
   // paths handle legit mappings in real time; the periodic relink is only a
   // safety net for context-overflow continuations, which can wait 5 minutes.
   const RELINK_GRACE_MS = 5 * 60 * 1000;
+  const STARTUP_MAINTENANCE_GRACE_MS = positiveInteger(process.env.CTM_STARTUP_MAINTENANCE_GRACE_MS, 5 * 60 * 1000);
   function _isInRelinkGraceWindow() {
     if (typeof isRestoreInProgress === 'function' && isRestoreInProgress()) return true;
     if (typeof getServerStartedAt === 'function') {
@@ -126,21 +195,73 @@ function registerSessionJobs(scheduler, deps) {
     }
     return false;
   }
+  function _isInStartupMaintenanceQuietWindow() {
+    if (typeof isRestoreInProgress === 'function' && isRestoreInProgress()) return true;
+    // Defer while the single serial db-owner worker is degraded under load: piling more
+    // maintenance onto a struggling worker deepens the contention cascade that wedges the
+    // cold-boot storm. The scheduler re-runs the job once the worker recovers.
+    if (typeof isDbWorkerDegraded === 'function' && isDbWorkerDegraded()) return true;
+    // isDbWarming() is currently a retired compatibility gate; keep honoring it
+    // here so any future SQLite-owned warmup can defer maintenance safely. The
+    // fixed startup grace below remains the active maintenance quiet window.
+    if (typeof isDbWarming === 'function' && isDbWarming()) return true;
+    if (typeof getServerStartedAt === 'function') {
+      const startedAt = Number(getServerStartedAt());
+      if (Number.isFinite(startedAt) && startedAt > 0 && (Date.now() - startedAt) < STARTUP_MAINTENANCE_GRACE_MS) {
+        return true;
+      }
+    }
+    if (typeof getRestoreCompletedAt === 'function') {
+      const completedAt = Number(getRestoreCompletedAt());
+      if (Number.isFinite(completedAt) && completedAt > 0 && (Date.now() - completedAt) < STARTUP_MAINTENANCE_GRACE_MS) {
+        return true;
+      }
+    }
+    return false;
+  }
+  // Interactive guard: heavy maintenance jobs (the io-pool scans) must not START
+  // their synchronous DB/fs work within INTERACTIVE_DEFER_MS of a user keystroke.
+  // Those scans block the event loop, and a keystroke that lands while one runs
+  // stalls until the loop frees — the measured cause of per-keystroke lag. The
+  // jobs are safety nets, so deferring a few seconds is harmless. INTERACTIVE_MAX_
+  // DEFER_MS caps the defer so continuous typing can't starve maintenance forever.
+  const INTERACTIVE_DEFER_MS = positiveInteger(process.env.CTM_MAINT_INTERACTIVE_DEFER_MS, 1500);
+  const INTERACTIVE_MAX_DEFER_MS = positiveInteger(process.env.CTM_MAINT_INTERACTIVE_MAX_DEFER_MS, 20000);
+  let _interactiveDeferSince = 0;
+  function _userInteractingNow() {
+    if (typeof getLastUserInteractiveInputAt !== 'function') return false;
+    const last = Number(getLastUserInteractiveInputAt()) || 0;
+    return last > 0 && (Date.now() - last) < INTERACTIVE_DEFER_MS;
+  }
+  function _canRunStartupMaintenance() {
+    if (_isInStartupMaintenanceQuietWindow()) return false;
+    if (_userInteractingNow()) {
+      const now = Date.now();
+      if (!_interactiveDeferSince) _interactiveDeferSince = now;
+      // Starvation cap: once we've been deferring for MAX_DEFER, let a run through
+      // (then re-arm the window so we keep yielding to bursts of typing).
+      if (now - _interactiveDeferSince < INTERACTIVE_MAX_DEFER_MS) return false;
+    }
+    _interactiveDeferSince = 0;
+    return true;
+  }
 
   let sessionMetadataSyncCursor = 0;
   let ghostReaperLegacyCursor = 0;
   let ghostReaperAgentCursor = 0;
 
   // --- jsonl-reconciliation: safety-net full scan (catches fs.watch misses) ---
-  // Runs after startup settles, then every 10min. fs.watch is the primary
-  // detector; this is the reliability guarantee. Keeping the initial full scan
-  // out of the first interaction window prevents typing stalls after restart.
+  // Runs immediately, then every 10min. fs.watch is the primary detector; this
+  // is the reliability guarantee. The work itself is bounded and yields between
+  // batches, so freshness is not traded for arbitrary startup quiet time.
   scheduler.register({
     name: 'jsonl-reconciliation',
-    intervalMs: 15 * 60 * 1000,
-    startDelayMs: 9 * 60 * 1000,
+    heavy: true, // long synchronous DB-map build + per-file parse; cap to 1 heavy/tick
+    intervalMs: 10 * 60 * 1000,
+    startDelayMs: 0,
     priority: 4,
     pool: 'io',
+    shouldRun: _canRunStartupMaintenance,
     run: async () => {
       const files = await getAllSessionFilesAsync();
       const db = dbModule.getDb();
@@ -158,10 +279,15 @@ function registerSessionJobs(scheduler, deps) {
       const claimedMap = {};
       const existingMap = new Map();
       try {
-        for (const r of db.prepare("SELECT agent_session_id, ctm_session_id, file_size, modified_at FROM agent_sessions").all()) {
-          existingMap.set(r.agent_session_id, r);
-          if (r.ctm_session_id) claimedMap[r.agent_session_id] = r.ctm_session_id;
-        }
+        // This loads EVERY agent_sessions row in one synchronous span; it grows
+        // with session count and is a prime event-loop-block suspect. Wrap it so
+        // a [perf-lag] block here is attributed by name instead of `(unknown)`.
+        runSync('jsonl-reconciliation:loadAgentSessionsMap', () => {
+          for (const r of db.prepare("SELECT agent_session_id, ctm_session_id, file_size, modified_at FROM agent_sessions").all()) {
+            existingMap.set(r.agent_session_id, r);
+            if (r.ctm_session_id) claimedMap[r.agent_session_id] = r.ctm_session_id;
+          }
+        });
       } catch (e) { console.error('[jsonl-reconciliation] metadata map build error:', e.message); }
 
       const updateMetadata = db.prepare("UPDATE agent_sessions SET file_size = ?, modified_at = ?, updated_at = datetime('now') WHERE agent_session_id = ?");
@@ -194,19 +320,20 @@ function registerSessionJobs(scheduler, deps) {
       }
 
       for (let index = 0; index < files.length; index++) {
-        const { filePath, projectPath, projectEntry } = files[index];
+        const { filePath, projectPath, projectEntry, sessionId: discoveredSessionId } = files[index];
         try {
           const virtualSession = claudeDesktopSessions.parseVirtualSessionPath(filePath);
-          const sessionId = virtualSession ? virtualSession.sessionId : path.basename(filePath).replace(/\.jsonl(\.bak)?$/, '');
+          const fileSessionId = virtualSession ? virtualSession.sessionId : path.basename(filePath).replace(/\.jsonl(\.bak)?$/, '');
+          let agentSessionId = String(discoveredSessionId || fileSessionId || '').trim();
           const statPath = claudeDesktopSessions.sourcePathForStat(filePath);
           const stat = await fsp.stat(statPath);
           const modifiedAt = stat.mtime.toISOString();
-          const existing = existingMap.get(sessionId);
+          let existing = existingMap.get(agentSessionId) || existingMap.get(fileSessionId);
 
           if (existing) {
             // Update metadata if stale
             if (existing.file_size !== stat.size || existing.modified_at !== modifiedAt) {
-              pendingMetadataUpdates.push({ sessionId, fileSize: stat.size, modifiedAt });
+              pendingMetadataUpdates.push({ sessionId: existing.agent_session_id || agentSessionId, fileSize: stat.size, modifiedAt });
               existing.file_size = stat.size;
               existing.modified_at = modifiedAt;
               upserted++;
@@ -219,8 +346,22 @@ function registerSessionJobs(scheduler, deps) {
           // New file not in DB — parse and insert. parseSessionFile reads a
           // bounded head/tail slice synchronously, so yield around it during
           // startup scans rather than wrapping hundreds of parses in one turn.
+          // Wrap the sync parse so a [perf-lag] block lands as a named span.
           await maybeYield();
-          const parsed = parseSessionFile(filePath, projectPath, projectEntry);
+          const parsed = runSync('jsonl-reconciliation:parseSessionFile', () => parseSessionFile(filePath, projectPath, projectEntry));
+          agentSessionId = String(parsed.sessionId || agentSessionId || fileSessionId || '').trim();
+          existing = existingMap.get(agentSessionId);
+          if (existing) {
+            if (existing.file_size !== stat.size || existing.modified_at !== modifiedAt) {
+              pendingMetadataUpdates.push({ sessionId: agentSessionId, fileSize: stat.size, modifiedAt });
+              existing.file_size = stat.size;
+              existing.modified_at = modifiedAt;
+              upserted++;
+              if (pendingMetadataUpdates.length >= 25) flushMetadataUpdates();
+            }
+            await maybeYield(index % 20 === 19);
+            continue;
+          }
 
           // Skip ephemeral/aborted sessions (tiny file, no content) — prevents ghost rows
           if (parsed.fileSize < 1024 && !parsed.userMsgCount && !parsed.title && !parsed.firstMessage) {
@@ -228,29 +369,73 @@ function registerSessionJobs(scheduler, deps) {
             continue;
           }
 
-          const ctmTabId = claimedMap[sessionId];
+          const lineage = parsedThreadLineage(parsed);
+          const parsedProvider = normalizeAgentType(parsed.agent || '') || parsed.agent || 'claude';
+          if (isProviderChildParsedSession(parsed)) {
+            try {
+              dbModule.upsertAgentSessionIdentity(agentSessionId, {
+                provider: parsedProvider,
+                providerResumeId: agentSessionId,
+                projectEntry: parsed.projectEntry || projectEntry,
+                projectPath: parsed.project || parsed.cwd || projectPath,
+                cwd: parsed.cwd || parsed.project || projectPath,
+                title: parsed.title || '',
+                firstMessage: parsed.firstMessage || '',
+                jsonlPath: filePath,
+                fileSize: parsed.fileSize || stat.size,
+                modifiedAt: parsed.modifiedAt || modifiedAt,
+                createdAt: parsed.timestamp || '',
+                model: parsed.modelId || parsed.model || '',
+                gitBranch: parsed.gitBranch || '',
+                slug: parsed.slug || '',
+                userMsgCount: parsed.userMsgCount || 0,
+                hostname: HOSTNAME,
+                ...lineage,
+              });
+              existingMap.set(agentSessionId, {
+                agent_session_id: agentSessionId,
+                ctm_session_id: null,
+                file_size: parsed.fileSize || stat.size,
+                modified_at: parsed.modifiedAt || modifiedAt,
+              });
+              upserted++;
+            } catch (e) {
+              console.error(`[jsonl-reconciliation] child identity upsert error for ${agentSessionId}:`, e.message);
+            }
+            await maybeYield(index % 10 === 9);
+            continue;
+          }
+
+          const ctmTabId = claimedMap[agentSessionId];
+          const parsedProjectEntry = parsed.projectEntry || projectEntry;
+          const parsedProjectPath = parsed.project || parsed.cwd || projectPath;
 
           if (ctmTabId) {
             // Already claimed by a CTM tab — update metadata
             pendingUpserts.push({ id: ctmTabId, data: {
-              agentSessionId: sessionId,
-              projectEntry, projectPath,
+              agentSessionId,
+              projectEntry: parsedProjectEntry,
+              projectPath: parsedProjectPath,
+              cwd: parsed.cwd || parsedProjectPath,
               jsonlPath: filePath,
               fileSize: parsed.fileSize,
               modifiedAt: parsed.modifiedAt,
               firstMessage: parsed.firstMessage || '',
               createdAt: parsed.timestamp || '',
-              provider: parsed.agent || 'claude',
-              model: parsed.modelId || '',
+              provider: parsedProvider,
+              model: parsed.modelId || parsed.model || '',
               gitBranch: parsed.gitBranch || '',
               slug: parsed.slug || '',
               userMsgCount: parsed.userMsgCount || 0,
+              hostname: HOSTNAME,
+              ...lineage,
             } });
           } else {
             // Standalone session — auto-create ctm_sessions + agent_sessions
-            pendingUpserts.push({ id: sessionId, data: {
-              agentSessionId: sessionId,
-              projectEntry, projectPath,
+            pendingUpserts.push({ id: agentSessionId, data: {
+              agentSessionId,
+              projectEntry: parsedProjectEntry,
+              projectPath: parsedProjectPath,
               cwd: parsed.cwd || projectPath,
               title: parsed.title || '',
               jsonlPath: filePath,
@@ -258,12 +443,13 @@ function registerSessionJobs(scheduler, deps) {
               modifiedAt: parsed.modifiedAt,
               firstMessage: parsed.firstMessage || '',
               createdAt: parsed.timestamp || '',
-              provider: parsed.agent || 'claude',
-              model: parsed.modelId || '',
+              provider: parsedProvider,
+              model: parsed.modelId || parsed.model || '',
               gitBranch: parsed.gitBranch || '',
               slug: parsed.slug || '',
               userMsgCount: parsed.userMsgCount || 0,
               hostname: HOSTNAME,
+              ...lineage,
             } });
           }
           if (pendingUpserts.length >= 3) {
@@ -281,15 +467,17 @@ function registerSessionJobs(scheduler, deps) {
   });
 
   // --- ghost-reaper: remove DB rows whose JSONL files no longer exist ---
-  // Runs hourly, well after startup, and checks a bounded round-robin batch. The
-  // old full-table scan could spend minutes walking Codex history paths and stall
-  // interactive terminal input.
+  // Checks a bounded round-robin batch. The old full-table scan could spend
+  // minutes walking Codex history paths; batching is the protection, not a long
+  // startup delay.
   scheduler.register({
     name: 'ghost-reaper',
-    intervalMs: 60 * 60 * 1000,
-    startDelayMs: 15 * 60 * 1000,
+    heavy: true,
+    intervalMs: 30 * 60 * 1000,
+    startDelayMs: 0,
     priority: 8,
     pool: 'io',
+    shouldRun: _canRunStartupMaintenance,
     run: async () => {
       const db = dbModule.getDb();
       let reaped = 0;
@@ -358,10 +546,12 @@ function registerSessionJobs(scheduler, deps) {
   // --- session-metadata-sync: update file metadata for active sessions ---
   scheduler.register({
     name: 'session-metadata-sync',
-    intervalMs: 5 * 60 * 1000,
-    startDelayMs: 5 * 60 * 1000,
+    heavy: true,
+    intervalMs: 30 * 1000,
+    startDelayMs: 0,
     priority: 5,
     pool: 'io',
+    shouldRun: _canRunStartupMaintenance,
     run: async () => {
       if (typeof deps.isConversationImportRunning === 'function' && deps.isConversationImportRunning()) {
         return { updated: 0, skipped: 'conversation_import_running' };
@@ -373,11 +563,16 @@ function registerSessionJobs(scheduler, deps) {
       const whereClause = hasProviderColumn
         ? "(jsonl_path != '' OR provider = 'codex')"
         : "jsonl_path != ''";
-      const rows = db.prepare(`SELECT agent_session_id, jsonl_path, file_size, modified_at, ${providerExpr} FROM agent_sessions WHERE ${whereClause} ORDER BY agent_session_id`).all();
       const maxRows = positiveInteger(process.env.CTM_METADATA_SYNC_ROWS_PER_RUN, 50);
-      const start = Math.min(sessionMetadataSyncCursor, Math.max(0, rows.length - 1));
-      const batch = rows.slice(start, Math.min(start + maxRows, rows.length));
-      sessionMetadataSyncCursor = (start + batch.length) >= rows.length ? 0 : start + batch.length;
+      // Load only this run's batch via SQL LIMIT/OFFSET. The previous `.all()`
+      // pulled EVERY agent_sessions row into memory each tick (then sliced 50) —
+      // a synchronous main-thread load that grew with session count and was a
+      // top event-loop-block offender. Keyset over the stable agent_session_id
+      // order; wrap to the start when a short page signals the end.
+      const batch = db.prepare(
+        `SELECT agent_session_id, jsonl_path, file_size, modified_at, ${providerExpr} FROM agent_sessions WHERE ${whereClause} ORDER BY agent_session_id LIMIT ? OFFSET ?`
+      ).all(maxRows, sessionMetadataSyncCursor);
+      sessionMetadataSyncCursor = batch.length < maxRows ? 0 : sessionMetadataSyncCursor + maxRows;
       const updateMetadata = db.prepare("UPDATE agent_sessions SET jsonl_path = ?, file_size = ?, modified_at = ?, updated_at = datetime('now') WHERE agent_session_id = ?");
       let lastYieldAt = Date.now();
 
@@ -387,10 +582,23 @@ function registerSessionJobs(scheduler, deps) {
         lastYieldAt = Date.now();
       }
 
+      // Offload the per-row fs.statSync to the read-pool as ONE batched `statFiles` call instead
+      // of a synchronous stat loop on the main event loop (the freeze). On pool unavailable/timeout
+      // statMap is null → fall back to the on-main resolver (only 50 rows). CTM_METADATA_SYNC_OFFLOAD=0 opts out.
+      let statMap = null;
+      if (process.env.CTM_METADATA_SYNC_OFFLOAD !== '0' && typeof statFilesOffThread === 'function') {
+        const statPaths = [...new Set(batch
+          .map((r) => claudeDesktopSessions.sourcePathForStat(r.jsonl_path || ''))
+          .filter(Boolean))];
+        try {
+          statMap = await statFilesOffThread(statPaths, positiveInteger(process.env.CTM_METADATA_SYNC_READPOOL_TIMEOUT_MS, 10000));
+        } catch { statMap = null; }
+      }
+
       for (let index = 0; index < batch.length; index++) {
         const row = batch[index];
         try {
-          const fileInfo = resolveAgentSessionJsonlInfo(row);
+          const fileInfo = statMap ? resolveJsonlInfoFromStatMap(row, statMap) : resolveAgentSessionJsonlInfo(row);
           if (!fileInfo) continue;
           const stat = fileInfo.stat;
           const newMtime = stat.mtime.toISOString();
@@ -401,17 +609,18 @@ function registerSessionJobs(scheduler, deps) {
         } catch (e) { console.error(`[session-metadata-sync] error for ${row.agent_session_id}:`, e.message); }
         await maybeYield(index % 25 === 24);
       }
-      return { updated, checked: batch.length, total: rows.length, partial: sessionMetadataSyncCursor !== 0 };
+      return { updated, checked: batch.length, partial: sessionMetadataSyncCursor !== 0 };
     },
   });
 
   // --- auto-title: AI-generated titles ---
   scheduler.register({
     name: 'auto-title',
-    intervalMs: 15 * 60 * 1000,
-    startDelayMs: 13 * 60 * 1000,
+    intervalMs: 5 * 60 * 1000,
+    startDelayMs: 30 * 1000,
     priority: 7,
     pool: 'llm',
+    shouldRun: _canRunStartupMaintenance,
     run: async () => {
       await runAutoTitleGeneration();
       return { done: true };
@@ -424,10 +633,11 @@ function registerSessionJobs(scheduler, deps) {
   // synthesize startup_tasks mappings from live runtime state.
   scheduler.register({
     name: 'session-healer',
-    intervalMs: 10 * 60 * 1000,
-    startDelayMs: 7 * 60 * 1000,
+    intervalMs: 5 * 60 * 1000,
+    startDelayMs: 30 * 1000,
     priority: 6,
     pool: 'io',
+    shouldRun: _canRunStartupMaintenance,
     run: async () => {
       await healStartupTaskSessionIds();
       return { done: true };
@@ -438,8 +648,9 @@ function registerSessionJobs(scheduler, deps) {
   scheduler.register({
     name: 'session-integrity',
     intervalMs: 30 * 60 * 1000,
-    startDelayMs: 20 * 60 * 1000,
+    startDelayMs: 60 * 1000,
     priority: 8,
+    shouldRun: _canRunStartupMaintenance,
     run: async () => {
       const result = deps.runSessionIntegrity
         ? await deps.runSessionIntegrity()
@@ -450,6 +661,55 @@ function registerSessionJobs(scheduler, deps) {
     },
   });
 
+  // --- approval-self-adapt: keep the learned approval-detection rule set healthy
+  // (retire rules whose patterns no longer compile/are unsafe). The behavioral
+  // learning signals fire inline on user input; this is the periodic GC. ---
+  if (deps.approvalSelfAdapt && deps.approvalAiRefinement) {
+    scheduler.register({
+      name: 'approval-self-adapt',
+      intervalMs: 45 * 60 * 1000,
+      startDelayMs: 90 * 1000,
+      priority: 4,
+      pool: 'io',
+      // runSelfAdaptMaintenance is synchronous and has been seen blocking the
+      // event loop for several seconds (recompiles/validates the learned rule
+      // set). Defer it out of the startup-quiet window and away from active
+      // typing — the interactive guard's starvation cap still forces it to run.
+      shouldRun: _canRunStartupMaintenance,
+      run: async () => {
+        const result = deps.approvalSelfAdapt.runSelfAdaptMaintenance({
+          dbModule,
+          refinement: deps.approvalAiRefinement,
+        });
+        if (result && result.disabled) {
+          console.log(`[approval-self-adapt] maintenance: checked=${result.checked} retired=${result.disabled} kept=${result.kept}`);
+        }
+        return result || { checked: 0 };
+      },
+    });
+  }
+
+  // --- walle-health-watchdog: detect unrecoverable Wall-E failures and raise
+  // a repair incident (notify + offer full-auto coding-agent repair). ---
+  if (deps.walleRepair) {
+    scheduler.register({
+      name: 'walle-health-watchdog',
+      intervalMs: 20000,
+      startDelayMs: 45000,
+      priority: 7,
+      pool: 'io',
+      // Health detection a few seconds late is fine; never let the 20s watchdog
+      // tick block keystroke echo. Defer during the startup-quiet window (Wall-E
+      // is still booting → avoids false-positive failure detection) and while
+      // the user is typing. Starvation cap bounds the defer to ~20s.
+      shouldRun: () => process.env.WALLE_REPAIR_DISABLED !== '1' && _canRunStartupMaintenance(),
+      run: async () => {
+        const result = await deps.walleRepair.onWatchdogTick();
+        return result || { ticked: true };
+      },
+    });
+  }
+
   // --- session-relink: detect continuation files for active sessions ---
   scheduler.register({
     name: 'session-relink',
@@ -474,7 +734,7 @@ function registerSessionJobs(scheduler, deps) {
 
           let newerMatch = null;
           let newerMtime = 0;
-          for (const file of fs.readdirSync(session._claudeProjectDir)) {
+          for (const file of _cachedRelinkReaddir(session._claudeProjectDir)) {
             if (!file.endsWith('.jsonl')) continue;
             const csId = file.replace(/\.jsonl$/, '');
             if (csId === session._claudeSessionId) continue;
@@ -561,11 +821,19 @@ function registerSessionJobs(scheduler, deps) {
   if (syncCodingSessionModels) {
     scheduler.register({
       name: 'model-sync',
-      intervalMs: 30000,
+      intervalMs: Math.max(3000, Number(process.env.CTM_MODEL_SYNC_INTERVAL_MS) || 5000),
       startDelayMs: 5000,
       priority: 9,
-      run: () => {
-        syncCodingSessionModels();
+      shouldRun: _canRunStartupMaintenance,
+      run: async () => {
+        // Prefer the off-thread variant: the claude JSONL scan + Codex state-DB reads run on the
+        // read-pool worker; only the small apply (model→registry, title decision, session mutate)
+        // stays on main. Falls back to the synchronous version when offload is disabled.
+        if (process.env.CTM_MODEL_SYNC_OFFLOAD !== '0' && typeof deps.syncCodingSessionModelsOffThread === 'function') {
+          await deps.syncCodingSessionModelsOffThread();
+        } else {
+          syncCodingSessionModels();
+        }
         return { done: true };
       },
     });
@@ -575,29 +843,62 @@ function registerSessionJobs(scheduler, deps) {
   if (deps.runIncrementalConversationImport) {
     scheduler.register({
       name: 'conversation-import',
+      heavy: true,
       intervalMs: 10 * 60 * 1000,
-      startDelayMs: 11 * 60 * 1000,
+      startDelayMs: 0,
       priority: 6,
       pool: 'io',
+      shouldRun: _canRunStartupMaintenance,
       run: async () => {
         return await deps.runIncrementalConversationImport();
       },
     });
   }
 
+  // --- cursor-conversation-import: import Cursor blob-graph stores → session_conversations ---
+  // Cursor conversations aren't JSONL; they're a content-addressed blob graph that is
+  // expensive to reconstruct. Import them on a cadence (off the main thread, on the db-owner
+  // worker) so the cache read path serves them instead of reconstructing on every UI poll.
+  // Signature-gated inside the job, so idle stores cost ~nothing; runs even when there are no
+  // cursor sessions (then it's a no-op query).
+  if (deps.runCursorConversationImport) {
+    scheduler.register({
+      name: 'cursor-conversation-import',
+      heavy: true,
+      intervalMs: Math.max(60 * 1000, Number(process.env.CTM_CURSOR_IMPORT_INTERVAL_MS) || 3 * 60 * 1000),
+      startDelayMs: 15 * 1000,
+      priority: 7,
+      pool: 'io',
+      shouldRun: _canRunStartupMaintenance,
+      run: async () => {
+        return await deps.runCursorConversationImport();
+      },
+    });
+  }
+
   // --- message-backfill: extract session_messages from session_conversations for FTS ---
   if (deps.backfillSessionMessages) {
     scheduler.register({
       name: 'message-backfill',
+      heavy: true,
       intervalMs: 10 * 60 * 1000,
-      startDelayMs: 15 * 60 * 1000,
+      startDelayMs: 0,
+      dependsOn: ['conversation-import'],
+      cascadeFrom: ['conversation-import'],
+      // Only cascade when conversation-import actually imported a session. The default
+      // cascade check fires on ANY numeric > 0 in the import result — including `total`
+      // (sessions on disk) and `scanned` — so an idle import scan that imported nothing
+      // still triggered a backfill on nearly every 5s tick (347 runs / 33 min in one
+      // sample, churning the db-owner worker + write lock). Gate on real new work.
+      cascadeCheck: (result) => Number(result && result.imported) > 0,
       priority: 8,
       pool: 'io',
+      shouldRun: _canRunStartupMaintenance,
       run: async () => {
-        const count = deps.backfillSessionMessagesAsync
+        const result = deps.backfillSessionMessagesAsync
           ? await deps.backfillSessionMessagesAsync({ limit: 1, chunkSize: 10 })
           : deps.backfillSessionMessages();
-        return { extracted: count };
+        return result && typeof result === 'object' ? result : { extracted: Number(result || 0) };
       },
     });
   }
@@ -609,10 +910,11 @@ function registerSessionJobs(scheduler, deps) {
   scheduler.register({
     name: 'persist-agent-session-id',
     intervalMs: 60 * 1000,
-    startDelayMs: 6 * 60 * 1000,
+    startDelayMs: 45 * 1000,
     priority: 6,
     pool: 'io',
-    run: () => {
+    shouldRun: _canRunStartupMaintenance,
+    run: async () => {
       let synced = 0;
       let skippedNoMapping = 0;
       try {
@@ -620,7 +922,12 @@ function registerSessionJobs(scheduler, deps) {
         const rows = dbModule.getDb().prepare(
           `SELECT * FROM startup_tasks WHERE (cmd LIKE '%claude%' OR cmd LIKE '%codex%' OR cmd LIKE '%gemini%')`
         ).all();
+        // Per-row resolution does several DB queries + a cwd fs check; over many rows this
+        // is an unbounded synchronous main-thread scan. Yield to the loop every ~25ms so a
+        // large startup_tasks table can't stall keystroke echo (matches session-metadata-sync).
+        let _lastYield = Date.now();
         for (const r of rows) {
+          if (Date.now() - _lastYield > 25) { await yieldToEventLoop(); _lastYield = Date.now(); }
           const ctmSessionId = r.ctm_session_id;
           const session = sessions.get(ctmSessionId);
           const agentType = detectAgentType(r.cmd || session?.cmd || '') || normalizeAgentType(r.type || session?.type || '');
@@ -647,7 +954,14 @@ function registerSessionJobs(scheduler, deps) {
           const projectDir = choice.row?.jsonl_path ? path.dirname(choice.row.jsonl_path) : (r.agent_project_dir || r.claude_project_dir || '');
           const currentProjectDir = r.agent_project_dir || r.claude_project_dir || '';
           const hasLegacyProjectDir = cols.has('agent_project_dir') || cols.has('claude_project_dir');
-          if (currentArgs === nextArgs && (!hasLegacyProjectDir || currentProjectDir === projectDir)) continue;
+          const cwdChoice = resolveRestoreCwdFromAgentSession({
+            task: { ...r, cwd: r.cwd, ctm_session_id: ctmSessionId, session_id: ctmSessionId },
+            row: choice.row,
+            agentType,
+            fsExists: fs.existsSync,
+          });
+          const needsCwdHeal = !!(cwdChoice.changed && cwdChoice.cwd && cwdChoice.cwd !== r.cwd);
+          if (currentArgs === nextArgs && (!hasLegacyProjectDir || currentProjectDir === projectDir) && !needsCwdHeal) continue;
           try {
             dbModule.updateStartupTaskAgentSession(
               ctmSessionId,
@@ -655,6 +969,9 @@ function registerSessionJobs(scheduler, deps) {
               projectDir,
               choice.args
             );
+            if (needsCwdHeal && typeof dbModule.updateStartupTaskCwd === 'function') {
+              dbModule.updateStartupTaskCwd(ctmSessionId, cwdChoice.cwd);
+            }
             synced++;
           } catch (e) { console.error('[persist-agent-session-id] update error:', e.message); }
         }
@@ -671,15 +988,36 @@ function registerSessionJobs(scheduler, deps) {
  * @param {import('./session-stream').SessionStream} deps.sessionStream
  */
 function registerStreamJobs(scheduler, deps) {
-  const { sessionStream } = deps;
+  const { sessionStream, isRestoreInProgress, getServerStartedAt, getRestoreCompletedAt, isDbWarming, isDbWorkerDegraded } = deps;
   if (!sessionStream) return;
+  const STARTUP_MAINTENANCE_GRACE_MS = positiveInteger(process.env.CTM_STARTUP_MAINTENANCE_GRACE_MS, 5 * 60 * 1000);
+  function _canRunStartupMaintenance() {
+    if (typeof isRestoreInProgress === 'function' && isRestoreInProgress()) return false;
+    // Defer while the serial db-owner worker is degraded under load (cold-boot contention cascade).
+    if (typeof isDbWorkerDegraded === 'function' && isDbWorkerDegraded()) return false;
+    if (typeof isDbWarming === 'function' && isDbWarming()) return false;
+    if (typeof getServerStartedAt === 'function') {
+      const startedAt = Number(getServerStartedAt());
+      if (Number.isFinite(startedAt) && startedAt > 0 && (Date.now() - startedAt) < STARTUP_MAINTENANCE_GRACE_MS) {
+        return false;
+      }
+    }
+    if (typeof getRestoreCompletedAt === 'function') {
+      const completedAt = Number(getRestoreCompletedAt());
+      if (Number.isFinite(completedAt) && completedAt > 0 && (Date.now() - completedAt) < STARTUP_MAINTENANCE_GRACE_MS) {
+        return false;
+      }
+    }
+    return true;
+  }
 
   // stream-cleanup: remove stale non-CTM sessions inactive >30min
   scheduler.register({
     name: 'stream-cleanup',
     intervalMs: 10 * 60 * 1000,
-    startDelayMs: 5 * 60 * 1000,
+    startDelayMs: 30 * 1000,
     priority: 9,
+    shouldRun: _canRunStartupMaintenance,
     run: () => {
       const cleaned = sessionStream.cleanStale();
       return { cleaned };
@@ -689,10 +1027,12 @@ function registerStreamJobs(scheduler, deps) {
   // stream-reconciliation: stat all tracked files, trigger incremental read if changed
   scheduler.register({
     name: 'stream-reconciliation',
-    intervalMs: 10 * 60 * 1000,
-    startDelayMs: 8 * 60 * 1000,
+    heavy: true,
+    intervalMs: 60 * 1000,
+    startDelayMs: 30 * 1000,
     priority: 5,
     pool: 'io',
+    shouldRun: _canRunStartupMaintenance,
     run: async () => {
       return await sessionStream.reconcile({ maxSessions: 12, maxChunksPerSession: 4 });
     },