ei-tui 1.6.2 → 1.6.4

package/src/core/processor.ts

@@ -35,7 +35,11 @@ import { QueueProcessor } from "./queue-processor.js";
 import { handlers } from "./handlers/index.js";
 import { normalizeRoomMessages, getMessageContent } from "./handlers/utils.js";
 import { sanitizeEiPersonaIdentifiers } from "./utils/identifier-utils.js";
+import { qualifyEiMessage } from "./utils/message-id.js";
 import { ContextStatus as ContextStatusEnum, RoomMode } from "./types.js";
+import { bootstrapTools } from "./bootstrap-tools.js";
+import { seedBuiltinFacts, migrateLearnedOn, migrateMessageIds, migrateSlackToMultiWorkspace, seedSettings } from "./migrations.js";
+import { IntegrationSyncManager } from "./integration-sync-manager.js";
 import { registerFindMemoryExecutor, registerFetchMemoryExecutor, registerFetchMessageExecutor, registerFileReadExecutor, registerPersonaNoteExecutors, buildPersonaNoteTools, SYSTEM_TOOLS } from "./tools/index.js";
 import { createAddNoteExecutor, createClearNoteExecutor } from "./tools/builtin/persona-notes.js";
 import { createFindMemoryExecutor } from "./tools/builtin/find-memory.js";
@@ -46,7 +50,6 @@ import { EMMETT_PERSONA_DEFINITION } from "../templates/emmett.js";
 import { shouldStartCeremony, startCeremony, handleCeremonyProgress, queueReflectionDrain, queueUserDedupRequest, queueRoomCapture, queuePersonaCapture, checkAndQueueRoomExtraction, queueTargetedPersonUpdate, queueTargetedTopicUpdate } from "./orchestrators/index.js";
 import { finishDocumentBatch } from "./handlers/document-segmentation.js";
 import { buildSynthesisPrompt } from "../prompts/synthesis/index.js";
-import { BUILT_IN_FACTS } from "./constants/built-in-facts.js";
 import { DEFAULT_SEED_TRAITS } from "./constants/seed-traits.js";
 
 // Static module imports
@@ -140,15 +143,8 @@ import {
 import type { RoomCreationInput, RoomEntity, RoomMessage, RoomSummary } from "./types.js";
 import { previewUnsource as _previewUnsource } from "../integrations/document/unsource.js";
 import type { UnsourcePreview, UnsourceResult } from "../integrations/document/unsource.js";
-import { isQualifiedMessageId, qualifyEiMessage, qualifyOpenCodeMessage } from "./utils/message-id.js";
-
-import type { IOpenCodeReader } from "../integrations/opencode/types.js";
 
 const DEFAULT_LOOP_INTERVAL_MS = 100;
-const DEFAULT_OPENCODE_POLLING_MS = 60000;
-const DEFAULT_CLAUDE_CODE_POLLING_MS = 60000;
-const DEFAULT_CURSOR_POLLING_MS = 60000;
-const DEFAULT_CODEX_POLLING_MS = 60000;
 
 let processorInstanceCount = 0;
 
@@ -164,20 +160,11 @@ export class Processor {
   private instanceId: number;
   private currentRequest: LLMRequest | null = null;
   private isTUI = false;
-  private lastOpenCodeSync = 0;
   private lastDLQTrim = 0;
-  private openCodeImportInProgress = false;
-  private lastClaudeCodeSync = 0;
-  private claudeCodeImportInProgress = false;
-  private lastCursorSync = 0;
-  private cursorImportInProgress = false;
-  private lastCodexSync = 0;
-  private codexImportInProgress = false;
-  private lastSlackSync = 0;
-  private slackImportInProgress = false;
   private pendingConflict: StateConflictData | null = null;
   private storage: Storage | null = null;
   private importAbortController = new AbortController();
+  private syncManager: IntegrationSyncManager | null = null;
   private personaPreviewResolvers = new Map<string, { resolve: (r: PersonaGenerationResult) => void; reject: (e: Error) => void }>();
 
   constructor(ei: Ei_Interface) {
@@ -249,11 +236,11 @@ export class Processor {
       await this.bootstrapFirstRun();
     }
     this.bootstrapTools();
-    this.seedBuiltinFacts();
-    this.migrateLearnedOn();
-    await this.migrateMessageIds();
-    this.migrateSlackToMultiWorkspace();
-    this.seedSettings();
+    seedBuiltinFacts(this.stateManager);
+    migrateLearnedOn(this.stateManager);
+    await migrateMessageIds(this.stateManager, this.isTUI);
+    migrateSlackToMultiWorkspace(this.stateManager);
+    seedSettings(this.stateManager);
     registerFindMemoryExecutor(createFindMemoryExecutor(this.searchHumanData.bind(this), this.getPersonaList.bind(this), this.stateManager.getHuman.bind(this.stateManager)));
     registerFetchMemoryExecutor(createFetchMemoryExecutor(this.stateManager.getHuman.bind(this.stateManager)));
     registerPersonaNoteExecutors(
@@ -281,6 +268,7 @@ export class Processor {
         (roomId: string) => this.stateManager.getRoom(roomId)?.display_name ?? null
       ));
     }
+    this.syncManager = new IntegrationSyncManager(this.stateManager, this.isTUI, this.storage, this.importAbortController, this.interface);
     this.running = true;
     console.log(`[Processor ${this.instanceId}] initialized, starting loop`);
     this.runLoop();
@@ -310,7 +298,7 @@ export class Processor {
     this.stateManager.persona_add(eiEntity);
 
     const welcomeMessage: Message = {
-      id: crypto.randomUUID(),
+      id: qualifyEiMessage(crypto.randomUUID()),
       role: "system",
       content: EI_WELCOME_MESSAGE,
       timestamp: new Date().toISOString(),
@@ -496,761 +484,8 @@ export class Processor {
     return this.generateDocument(subject);
   }
 
-  /**
-   * Seed built-in tool providers and tools if they don't exist yet.
-   * Called on every startup (after state load/restore) — safe to call repeatedly.
-   * New builtins added in future releases will be seeded automatically.
-   */
   private bootstrapTools(): void {
-    const now = new Date().toISOString();
-
-    for (const name of ["find_memory", "fetch_memory", "fetch_message", "read_memory"]) {
-      const tool = this.stateManager.tools_getByName(name);
-      if (tool) this.stateManager.tools_remove(tool.id);
-    }
-
-    // --- Ei built-in provider ---
-    if (!this.stateManager.tools_getProviderById("ei")) {
-      const eiProvider: ToolProvider = {
-        id: "ei",
-        name: "ei",
-        display_name: "Ei Built-ins",
-        description: "Built-in tools that ship with Ei. No external API needed.",
-        builtin: true,
-        config: {},
-        enabled: true,
-        created_at: now,
-      };
-      this.stateManager.tools_addProvider(eiProvider);
-    }
-
-    // file_read tool (TUI only)
-    this.stateManager.tools_upsertBuiltin({
-        id: crypto.randomUUID(),
-        provider_id: "ei",
-        name: "file_read",
-        display_name: "Read File",
-        description:
-          "Read the contents of a file from the local filesystem. Use list_directory first to explore folder structure. Only available in the TUI.",
-        input_schema: {
-          type: "object",
-          properties: {
-            path: { type: "string", description: "Absolute or relative path to the file" },
-          },
-          required: ["path"],
-        },
-        runtime: "node",
-        builtin: true,
-        enabled: true,
-        created_at: now,
-        max_calls_per_interaction: 5,
-    });
-
-    // list_directory tool (TUI only)
-    this.stateManager.tools_upsertBuiltin({
-        id: crypto.randomUUID(),
-        provider_id: "ei",
-        name: "list_directory",
-        display_name: "List Directory",
-        description:
-          "List the contents of a directory on the local filesystem. Returns filenames prefixed with [FILE] or [DIR]. Use this to explore folder structure before reading files. Only available in the TUI.",
-        input_schema: {
-          type: "object",
-          properties: {
-            path: { type: "string", description: "Absolute or relative path to the directory (e.g. ~/Projects/myapp or /home/user/docs)" },
-          },
-          required: ["path"],
-        },
-        runtime: "node",
-        builtin: true,
-        enabled: true,
-        created_at: now,
-        max_calls_per_interaction: 5,
-    });
-
-    // directory_tree tool (TUI only)
-    this.stateManager.tools_upsertBuiltin({
-        id: crypto.randomUUID(),
-        provider_id: "ei",
-        name: "directory_tree",
-        display_name: "Directory Tree",
-        description:
-          "Show a recursive tree of a directory up to a configurable depth. Returns a JSON tree with name, type, and children fields. Default max_depth is 3, maximum is 8. Only available in the TUI.",
-        input_schema: {
-          type: "object",
-          properties: {
-            path: { type: "string", description: "Absolute or relative path to the directory" },
-            max_depth: { type: "number", description: "Maximum depth to recurse (1-8, default 3)" },
-          },
-          required: ["path"],
-        },
-        runtime: "node",
-        builtin: true,
-        enabled: true,
-        created_at: now,
-        max_calls_per_interaction: 3,
-    });
-
-    // search_files tool (TUI only)
-    this.stateManager.tools_upsertBuiltin({
-        id: crypto.randomUUID(),
-        provider_id: "ei",
-        name: "search_files",
-        display_name: "Search Files",
-        description:
-          "Recursively search for files by name pattern within a directory. Supports * wildcards. Returns matching absolute paths. Skips node_modules, .git, dist. Only available in the TUI.",
-        input_schema: {
-          type: "object",
-          properties: {
-            path: { type: "string", description: "Root directory to search from" },
-            pattern: { type: "string", description: "Filename glob pattern, e.g. \"*.ts\" or \"README*\"" },
-          },
-          required: ["path", "pattern"],
-        },
-        runtime: "node",
-        builtin: true,
-        enabled: true,
-        created_at: now,
-        max_calls_per_interaction: 3,
-    });
-
-    // grep tool (TUI only)
-    this.stateManager.tools_upsertBuiltin({
-        id: crypto.randomUUID(),
-        provider_id: "ei",
-        name: "grep",
-        display_name: "Grep",
-        description:
-          "Search file contents for lines matching a regex pattern. Recursively searches a directory (or a single file). Skips binary files and node_modules. Returns matching file, line number, and text. Only available in the TUI.",
-        input_schema: {
-          type: "object",
-          properties: {
-            pattern: { type: "string", description: "Regex pattern to search for" },
-            path: { type: "string", description: "File or directory to search" },
-            include: { type: "string", description: "Optional glob to filter filenames, e.g. \"*.ts\"" },
-            case_insensitive: { type: "boolean", description: "Case-insensitive match (default false)" },
-          },
-          required: ["pattern", "path"],
-        },
-        runtime: "node",
-        builtin: true,
-        enabled: true,
-        created_at: now,
-        max_calls_per_interaction: 5,
-    });
-
-    // get_file_info tool (TUI only)
-    this.stateManager.tools_upsertBuiltin({
-        id: crypto.randomUUID(),
-        provider_id: "ei",
-        name: "get_file_info",
-        display_name: "Get File Info",
-        description:
-          "Get metadata about a file or directory: type, size, permissions, created/modified/accessed timestamps. Only available in the TUI.",
-        input_schema: {
-          type: "object",
-          properties: {
-            path: { type: "string", description: "Absolute or relative path to the file or directory" },
-          },
-          required: ["path"],
-        },
-        runtime: "node",
-        builtin: true,
-        enabled: true,
-        created_at: now,
-        max_calls_per_interaction: 5,
-    });
-
-    // web_fetch tool
-    this.stateManager.tools_upsertBuiltin({
-        id: crypto.randomUUID(),
-        provider_id: "ei",
-        name: "web_fetch",
-        display_name: "Web Fetch",
-        description:
-          "Fetch content from a URL and return the text. Useful for reading web pages, documentation, or public APIs. HTML is stripped to plain text. Only available in the TUI.",
-        input_schema: {
-          type: "object",
-          properties: {
-            url: { type: "string", description: "The URL to fetch (http or https only)" },
-          },
-          required: ["url"],
-        },
-        runtime: "node",
-        builtin: true,
-        enabled: true,
-        created_at: now,
-        max_calls_per_interaction: 3,
-    });
-
-    // --- Tavily Search provider ---
-    if (!this.stateManager.tools_getProviderById("tavily")) {
-      const tavilyProvider: ToolProvider = {
-        id: "tavily",
-        name: "tavily",
-        display_name: "Tavily Search",
-        description:
-          "Browser-compatible web search. Requires a Tavily API key (free tier: 1000 requests/month).",
-        builtin: true,
-        config: { api_key: "" },
-        enabled: false,
-        created_at: now,
-      };
-      this.stateManager.tools_addProvider(tavilyProvider);
-    }
-
-    // tavily_web_search
-    this.stateManager.tools_upsertBuiltin({
-        id: crypto.randomUUID(),
-        provider_id: "tavily",
-        name: "tavily_web_search",
-        display_name: "Web Search",
-        description:
-          "Search the web using Tavily. Use for current events, fact verification, or any topic that benefits from up-to-date information.",
-        input_schema: {
-          type: "object",
-          properties: {
-            query: { type: "string", description: "Search query" },
-            max_results: { type: "number", description: "Number of results (default: 5, max: 10)" },
-          },
-          required: ["query"],
-        },
-        runtime: "any",
-        builtin: true,
-        enabled: true,
-        created_at: now,
-        max_calls_per_interaction: 3,
-    });
-
-    // tavily_news_search
-    this.stateManager.tools_upsertBuiltin({
-        id: crypto.randomUUID(),
-        provider_id: "tavily",
-        name: "tavily_news_search",
-        display_name: "News Search",
-        description:
-          "Search recent news articles using Tavily. Use for current events and recent developments.",
-        input_schema: {
-          type: "object",
-          properties: {
-            query: { type: "string", description: "News search query" },
-            max_results: { type: "number", description: "Number of results (default: 5, max: 10)" },
-          },
-          required: ["query"],
-        },
-        runtime: "any",
-        builtin: true,
-        enabled: true,
-        created_at: now,
-        max_calls_per_interaction: 3,
-    });
-
-    // --- Spotify provider ---
-    if (!this.stateManager.tools_getProviderById("spotify")) {
-      const spotifyProvider: ToolProvider = {
-        id: "spotify",
-        name: "spotify",
-        display_name: "Spotify",
-        description:
-          "Access your Spotify playback and music library. Connect via Settings → Tool Kits → Spotify.",
-        builtin: true,
-        config: { spotify_refresh_token: "" },
-        enabled: false,
-        created_at: now,
-      };
-      this.stateManager.tools_addProvider(spotifyProvider);
-    }
-
-    // get_currently_playing
-    this.stateManager.tools_upsertBuiltin({
-        id: crypto.randomUUID(),
-        provider_id: "spotify",
-        name: "get_currently_playing",
-        display_name: "Currently Playing",
-        description:
-          "Get the song currently playing on the user's Spotify. Returns artist, title, album, playback state, and progress. Returns nothing_playing if nothing is active.",
-        input_schema: {
-          type: "object",
-          properties: {},
-          required: [],
-        },
-        runtime: "any",
-        builtin: true,
-        enabled: true,
-        created_at: now,
-        max_calls_per_interaction: 3,
-    });
-
-    // get_liked_songs
-    this.stateManager.tools_upsertBuiltin({
-        id: crypto.randomUUID(),
-        provider_id: "spotify",
-        name: "get_liked_songs",
-        display_name: "Liked Songs",
-        description:
-          "Get the user's full Spotify liked songs library. Returns an array of { artist, title, added_at }. Results are cached for 30 minutes. Ask the user before calling — it may return thousands of tracks.",
-        input_schema: {
-          type: "object",
-          properties: {},
-          required: [],
-        },
-        runtime: "any",
-        builtin: true,
-        enabled: true,
-        created_at: now,
-        max_calls_per_interaction: 1,
-    });
-
-    // submit_response tool — auto-injected for Heartbeat steps only (HandleHeartbeatCheck).
-    // PersonaResponse and RoomResponse agents now use natural Markdown output instead.
-    // Not user-configurable; invisible in the tools UI. Terminates the tool loop immediately
-    // when called; its arguments become response.parsed.
-    this.stateManager.tools_upsertBuiltin({
-        id: crypto.randomUUID(),
-        provider_id: "ei",
-        name: "submit_response",
-        display_name: "Submit Response",
-        description: "Submit your response to the conversation. Call this when you are ready to respond — after any research or tool use is complete.",
-        input_schema: {
-          type: "object",
-          properties: {
-            should_respond: {
-              type: "boolean",
-              description: "Whether you are responding (true) or staying silent (false)",
-            },
-            content: {
-              type: "string",
-              description: "Your response in Markdown. Required when should_respond is true. Use _underscores_ for actions or stage directions inline with your text.",
-            },
-            reason: {
-              type: "string",
-              description: "Why you are staying silent. Only used when should_respond is false.",
-            },
-          },
-          required: ["should_respond"],
-          additionalProperties: false,
-        },
-        runtime: "any",
-        builtin: true,
-        enabled: true,
-        is_submit: true,
-        max_calls_per_interaction: 1,
-        created_at: now,
-    });
-
-    this.stateManager.tools_upsertBuiltin({
-        id: crypto.randomUUID(),
-        provider_id: "ei",
-        name: "submit_heartbeat_check",
-        display_name: "Submit Heartbeat Decision",
-        description: "Submit your decision on whether to reach out with a message. Call this when you have decided.",
-        input_schema: {
-          type: "object",
-          properties: {
-            should_respond: { type: "boolean", description: "Whether you want to initiate a message" },
-            topic: { type: "string", description: "The specific topic you want to discuss (when should_respond is true)" },
-            message: { type: "string", description: "Your actual message to them (when should_respond is true)" },
-          },
-          required: ["should_respond"],
-          additionalProperties: false,
-        },
-        runtime: "any",
-        builtin: true,
-        enabled: true,
-        is_submit: true,
-        max_calls_per_interaction: 1,
-        created_at: now,
-    });
-
-    this.stateManager.tools_upsertBuiltin({
-        id: crypto.randomUUID(),
-        provider_id: "ei",
-        name: "submit_ei_heartbeat",
-        display_name: "Submit Ei Heartbeat Decision",
-        description: "Submit your choice of item to follow up on, or indicate nothing warrants reaching out.",
-        input_schema: {
-          type: "object",
-          properties: {
-            should_respond: { type: "boolean", description: "Whether Ei wants to check in about an item" },
-            id: { type: "string", description: "ID of the item you chose (when should_respond is true)" },
-            my_response: { type: "string", description: "The check-in message (for Person/Topic/Persona items)" },
-          },
-          required: ["should_respond"],
-          additionalProperties: false,
-        },
-        runtime: "any",
-        builtin: true,
-        enabled: true,
-        is_submit: true,
-        max_calls_per_interaction: 1,
-        created_at: now,
-    });
-
-    this.stateManager.tools_upsertBuiltin({
-        id: crypto.randomUUID(),
-        provider_id: "ei",
-        name: "submit_dedup_decisions",
-        display_name: "Submit Dedup Decisions",
-        description: "Submit your merge, remove, and add decisions for this cluster of records.",
-        input_schema: {
-          type: "object",
-          properties: {
-            update: {
-              type: "array",
-              description: "Records to update with merged data. Must include at least one (the canonical record).",
-              items: {
-                type: "object",
-                properties: {
-                  id: { type: "string" },
-                  type: { type: "string", enum: ["topic", "person", "trait"] },
-                  name: { type: "string" },
-                  description: { type: "string" },
-                  sentiment: { type: "number" },
-                  strength: { type: "number" },
-                  confidence: { type: "number" },
-                  exposure_current: { type: "number" },
-                  exposure_desired: { type: "number" },
-                  relationship: { type: "string" },
-                  category: { type: "string" },
-                  last_updated: { type: "string" },
-                },
-                required: ["id", "type", "name", "description"],
-                additionalProperties: false,
-              },
-            },
-            remove: {
-              type: "array",
-              description: "Duplicates to remove. Each must reference its canonical record via replaced_by.",
-              items: {
-                type: "object",
-                properties: {
-                  to_be_removed: { type: "string" },
-                  replaced_by: { type: "string" },
-                },
-                required: ["to_be_removed", "replaced_by"],
-                additionalProperties: false,
-              },
-            },
-            add: {
-              type: "array",
-              description: "New records to create. Only when merging reveals a missing concept.",
-              items: {
-                type: "object",
-                properties: {
-                  type: { type: "string", enum: ["topic", "person", "trait"] },
-                  name: { type: "string" },
-                  description: { type: "string" },
-                  sentiment: { type: "number" },
-                  strength: { type: "number" },
-                  confidence: { type: "number" },
-                  exposure_current: { type: "number" },
-                  exposure_desired: { type: "number" },
-                  relationship: { type: "string" },
-                  category: { type: "string" },
-                },
-                required: ["type", "name", "description"],
-                additionalProperties: false,
-              },
-            },
-          },
-          required: ["update", "remove", "add"],
-          additionalProperties: false,
-        },
-        runtime: "any",
-        builtin: true,
-        enabled: true,
-        is_submit: true,
-        max_calls_per_interaction: 1,
-        created_at: now,
-    });
-
-    // --- Reconcile pass: prune stale tool references from persona tool lists ---
-    // Build manifest of all tool IDs currently in state (everything seeded above).
-    const manifestIds = new Set(this.stateManager.tools_getAll().map(t => t.id));
-
-    for (const persona of this.stateManager.persona_getAll()) {
-      if (!persona.tools?.length) continue;
-      const pruned = persona.tools.filter(id => manifestIds.has(id));
-      if (pruned.length !== persona.tools.length) {
-        const removed = persona.tools.length - pruned.length;
-        this.stateManager.persona_update(persona.id, { tools: pruned });
-        console.log(`[Processor] Pruned ${removed} stale tool reference(s) from persona "${persona.display_name}"`);
-      }
-    }
-  }
-
-  /**
-   * Seed 25 built-in facts if they don't exist yet.
-   * Called on every startup — safe to call repeatedly.
-   * New facts are created with empty descriptions and validated_date.
-   */
-  private seedBuiltinFacts(): void {
-    const human = this.stateManager.getHuman();
-    const existingFactNames = new Set(human.facts.map(f => f.name));
-    
-    // BUILT_IN_FACTS imported at top of file
-    const now = new Date().toISOString();
-    let seededCount = 0;
-
-    for (const builtInFact of BUILT_IN_FACTS) {
-      if (existingFactNames.has(builtInFact.name)) continue;
-
-      const newFact: Fact = {
-        id: crypto.randomUUID(),
-        name: builtInFact.name,
-        description: '',
-        sentiment: 0,
-        validated_date: '',
-        last_updated: now,
-        learned_on: now,
-      };
-      human.facts.push(newFact);
-      seededCount++;
-    }
-
-    if (seededCount > 0) {
-      this.stateManager.setHuman(human);
-      console.log(`[Processor] Seeded ${seededCount} built-in facts`);
-    }
-  }
-
-  private migrateLearnedOn(): void {
-    const human = this.stateManager.getHuman();
-
-    const backfill = <T extends { learned_on?: string; last_updated: string }>(items: T[]): T[] =>
-      items.map(item => item.learned_on ? item : { ...item, learned_on: item.last_updated });
-
-    const facts = backfill(human.facts);
-    const topics = backfill(human.topics);
-    const people = backfill(human.people);
-
-    const changed =
-      facts.some((f, i) => f !== human.facts[i]) ||
-      topics.some((t, i) => t !== human.topics[i]) ||
-      people.some((p, i) => p !== human.people[i]);
-
-    if (changed) {
-      this.stateManager.setHuman({ ...human, facts, topics, people });
-      console.log("[Processor] Backfilled learned_on for existing data items");
-    }
-  }
-
-  private async migrateMessageIds(): Promise<void> {
-    try {
-      let msgRewrites = 0;
-      let quoteRewrites = 0;
-
-      const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-
-      const personas = this.stateManager.persona_getAll();
-      for (const persona of personas) {
-        for (const msg of this.stateManager.messages_get(persona.id)) {
-          if (!msg.external && UUID_PATTERN.test(msg.id)) {
-            this.stateManager.messages_update(persona.id, msg.id, { id: qualifyEiMessage(msg.id) });
-            msgRewrites++;
-          }
-        }
-      }
-
-      const rooms = this.stateManager.getRoomList();
-      for (const room of rooms) {
-        for (const msg of this.stateManager.getRoomMessages(room.id).slice()) {
-          if (UUID_PATTERN.test(msg.id)) {
-            this.stateManager.updateRoomMessage(room.id, msg.id, { id: qualifyEiMessage(msg.id) });
-            msgRewrites++;
-          }
-        }
-      }
-
-      const human = this.stateManager.getHuman();
-      const quotes = human.quotes ?? [];
-
-      const eiUuidMap = new Map<string, string>();
-      for (const persona of personas) {
-        for (const msg of this.stateManager.messages_get(persona.id)) {
-          if (msg.id.startsWith("ei:")) eiUuidMap.set(msg.id.slice(3), msg.id);
-        }
-      }
-      for (const room of rooms) {
-        for (const msg of this.stateManager.getRoomMessages(room.id)) {
-          if (msg.id.startsWith("ei:")) eiUuidMap.set(msg.id.slice(3), msg.id);
-        }
-      }
-
-      const MSG_PATTERN = /^msg_[a-zA-Z0-9]+$/;
-
-      let openCodeReader: IOpenCodeReader | null = null;
-      if (this.isTUI) {
-        const { createOpenCodeReader } = await import("../integrations/opencode/reader-factory.js");
-        openCodeReader = await createOpenCodeReader().catch(() => null);
-      }
-
-      const updatedQuotes: typeof quotes = [];
-      for (const quote of quotes) {
-        const mid = quote.message_id;
-        if (!mid || isQualifiedMessageId(mid)) {
-          updatedQuotes.push(quote);
-          continue;
-        }
-
-        if (MSG_PATTERN.test(mid)) {
-          if (openCodeReader) {
-            const ocWindow = await openCodeReader.getMessageById(mid).catch(() => null);
-            if (ocWindow) {
-              const { getMachineId } = await import("../integrations/machine-id.js");
-              updatedQuotes.push({ ...quote, message_id: qualifyOpenCodeMessage(getMachineId(), ocWindow.session.id, mid) });
-              quoteRewrites++;
-              continue;
-            }
-          }
-          updatedQuotes.push(quote);
-          continue;
-        }
-
-        if (UUID_PATTERN.test(mid)) {
-          const fqId = eiUuidMap.get(mid);
-          if (fqId) {
-            updatedQuotes.push({ ...quote, message_id: fqId });
-            quoteRewrites++;
-            continue;
-          }
-          updatedQuotes.push(quote);
-          continue;
-        }
-
-        updatedQuotes.push(quote);
-      }
-
-      if (quoteRewrites > 0) {
-        this.stateManager.setHuman({ ...human, quotes: updatedQuotes });
-      }
-
-      if (msgRewrites > 0 || quoteRewrites > 0) {
-        console.log(`[Processor] migrateMessageIds: rewrote ${msgRewrites} message IDs, ${quoteRewrites} quote message_ids`);
-      }
-    } catch (err) {
-      console.error("[Processor] migrateMessageIds failed, continuing:", err);
-    }
-  }
-
-  private migrateSlackToMultiWorkspace(): void {
-    const human = this.stateManager.getHuman();
-    const slack = human.settings?.slack as Record<string, unknown> | undefined;
-    if (!slack) return;
-
-    const hasLegacyAuth = "auth" in slack && slack.auth != null;
-    const hasLegacyIntegration = "integration" in slack;
-    if (!hasLegacyAuth && !hasLegacyIntegration) return;
-
-    const legacyAuth = slack.auth as Record<string, unknown> | undefined;
-    const workspaceId = (legacyAuth?.workspace_id as string | undefined) ?? "unknown";
-
-    const migratedWorkspace: Record<string, unknown> = {
-      integration: slack.integration,
-      extraction_model: slack.extraction_model,
-      last_sync: slack.last_sync,
-      backfill_days: slack.backfill_days,
-      broadcast_threshold: slack.broadcast_threshold,
-      channel_overrides: slack.channel_overrides,
-      channels: slack.channels,
-    };
-
-    if (legacyAuth) {
-      migratedWorkspace.auth = {
-        type: "oauth",
-        token: legacyAuth.token,
-        refresh_token: legacyAuth.refresh_token,
-        workspace_name: legacyAuth.workspace_name,
-      };
-    }
-
-    this.stateManager.setHuman({
-      ...human,
-      settings: {
-        ...human.settings,
-        slack: {
-          polling_interval_ms: slack.polling_interval_ms as number | undefined,
-          workspaces: { [workspaceId]: migratedWorkspace } as unknown as import("../integrations/slack/types.js").SlackSettings["workspaces"],
-        },
-      },
-    });
-
-    console.log(`[Processor] migrateSlackToMultiWorkspace: migrated legacy slack settings to workspaces[${workspaceId}]`);
-  }
-
-  private seedSettings(): void {
-    const human = this.stateManager.getHuman();
-    let modified = false;
-
-    if (!human.settings) {
-      human.settings = {};
-      modified = true;
-    }
-
-    if (!human.settings.opencode) {
-      human.settings.opencode = {
-        integration: false,
-        polling_interval_ms: 60000,
-      };
-      modified = true;
-    }
-
-    if (!human.settings.claudeCode) {
-      human.settings.claudeCode = {
-        integration: false,
-        polling_interval_ms: 60000,
-      };
-      modified = true;
-    }
-
-    if (!human.settings.codex) {
-      human.settings.codex = {
-        integration: false,
-        polling_interval_ms: 60000,
-      };
-      modified = true;
-    }
-
-    if (!human.settings.ceremony) {
-      human.settings.ceremony = {
-        time: "09:00",
-      };
-      modified = true;
-    }
-
-    if (!human.settings.backup) {
-      human.settings.backup = {
-        enabled: false,
-        max_backups: 24,
-        interval_ms: 3600000,
-      };
-      modified = true;
-    }
-
-    if (human.settings.default_heartbeat_ms == null) {
-      human.settings.default_heartbeat_ms = 1800000;
-      modified = true;
-    }
-
-    if (human.settings.default_context_window_ms == null) {
-      human.settings.default_context_window_ms = 28800000;
-      modified = true;
-    }
-
-    if (human.settings.message_min_count == null) {
-      human.settings.message_min_count = 0;
-      modified = true;
-    }
-
-    if (human.settings.message_max_age_days == null) {
-      human.settings.message_max_age_days = 0;
-      modified = true;
-    }
-
-    if (modified) {
-      this.stateManager.setHuman(human);
-      console.log(`[Processor] Seeded missing settings`);
-    }
+    bootstrapTools(this.stateManager);
   }
 
   async stop(): Promise<void> {
@@ -1280,26 +515,7 @@ export class Processor {
     this.running = false;
     this.queueProcessor.abort();
     this.importAbortController.abort();
-    if (this.openCodeImportInProgress) {
-      console.log(`[Processor ${this.instanceId}] Clearing openCodeImportInProgress flag`);
-      this.openCodeImportInProgress = false;
-    }
-    if (this.claudeCodeImportInProgress) {
-      console.log(`[Processor ${this.instanceId}] Clearing claudeCodeImportInProgress flag`);
-      this.claudeCodeImportInProgress = false;
-    }
-    if (this.cursorImportInProgress) {
-      console.log(`[Processor ${this.instanceId}] Clearing cursorImportInProgress flag`);
-      this.cursorImportInProgress = false;
-    }
-    if (this.codexImportInProgress) {
-      console.log(`[Processor ${this.instanceId}] Clearing codexImportInProgress flag`);
-      this.codexImportInProgress = false;
-    }
-    if (this.slackImportInProgress) {
-      console.log(`[Processor ${this.instanceId}] Clearing slackImportInProgress flag`);
-      this.slackImportInProgress = false;
-    }
+    this.syncManager?.resetImportFlags();
     await this.stateManager.flush();
     console.log(`[Processor ${this.instanceId}] pause() complete (main loop stopped, state flushed)`);
   }
@@ -1310,6 +526,7 @@ export class Processor {
       throw new Error(`Cannot resume a stopped processor (instanceId: ${this.instanceId})`);
     }
     this.importAbortController = new AbortController();
+    this.syncManager?.updateAbortController(this.importAbortController);
     this.running = true;
     this.runLoop();
     console.log(`[Processor ${this.instanceId}] resume() complete (main loop restarted)`);
@@ -1514,56 +731,8 @@ const toolNextSteps = new Set([
 
     const human = this.stateManager.getHuman();
 
-    if (
-      this.isTUI &&
-      human.settings?.opencode?.integration &&
-      this.stateManager.queue_length() === 0
-    ) {
-      await this.checkAndSyncOpenCode(human, now);
-    }
-
-    if (this.isTUI && human.settings?.backup?.enabled) {
-      await this.checkAndRunRollingBackup(human, now);
-    }
-    if (
-      this.isTUI &&
-      human.settings?.claudeCode?.integration &&
-      this.stateManager.queue_length() === 0
-    ) {
-      await this.checkAndSyncClaudeCode(human, now);
-    }
-
-    if (
-      this.isTUI &&
-      human.settings?.cursor?.integration &&
-      this.stateManager.queue_length() === 0
-    ) {
-      await this.checkAndSyncCursor(human, now);
-    }
-
-    if (
-      this.isTUI &&
-      human.settings?.codex?.integration &&
-      this.stateManager.queue_length() === 0
-    ) {
-      await this.checkAndSyncCodex(human, now);
-    }
-
-    if (
-      this.isTUI &&
-      human.settings?.personaHistory?.integration &&
-      !human.settings.personaHistory.complete &&
-      this.stateManager.queue_length() === 0
-    ) {
-      await this.checkAndSyncPersonaHistory(human);
-    }
-
-    if (
-      this.isTUI &&
-      Object.values(human.settings?.slack?.workspaces ?? {}).some(ws => ws.integration && ws.auth) &&
-      this.stateManager.queue_length() === 0
-    ) {
-      await this.checkAndSyncSlack(human, now);
+    if (this.syncManager) {
+      await this.syncManager.checkAll(human, now);
     }
 
     if (human.settings?.ceremony && shouldStartCeremony(human.settings.ceremony, this.stateManager)) {
@@ -1621,309 +790,6 @@ const toolNextSteps = new Set([
     }
   }
 
-  private async checkAndRunRollingBackup(human: HumanEntity, now: number): Promise<void> {
-    if (!this.storage) return;
-    const cfg = human.settings!.backup!;
-    const intervalMs = cfg.interval_ms ?? 3_600_000;
-    const maxBackups = cfg.max_backups ?? 24;
-    const lastBackup = cfg.last_backup ? new Date(cfg.last_backup).getTime() : 0;
-
-    if (now - lastBackup < intervalMs) return;
-
-    this.stateManager.setHuman({
-      ...this.stateManager.getHuman(),
-      settings: {
-        ...this.stateManager.getHuman().settings,
-        backup: { ...cfg, last_backup: new Date(now).toISOString() },
-      },
-    });
-
-    const state = this.stateManager.getStorageState();
-    try {
-      await this.storage.saveRollingBackup(state, maxBackups);
-      console.log(`[Processor] Rolling backup saved (max=${maxBackups})`);
-    } catch (err) {
-      console.warn(`[Processor] Rolling backup failed:`, err);
-    }
-  }
-
-  private async checkAndSyncOpenCode(human: HumanEntity, now: number): Promise<void> {
-    if (this.openCodeImportInProgress) {
-      return;
-    }
-
-    const opencode = human.settings?.opencode;
-    const pollingInterval = opencode?.polling_interval_ms ?? DEFAULT_OPENCODE_POLLING_MS;
-    const lastSync = opencode?.last_sync ? new Date(opencode.last_sync).getTime() : 0;
-    const timeSinceSync = now - lastSync;
-
-    if (timeSinceSync < pollingInterval && this.lastOpenCodeSync > 0) {
-      return;
-    }
-
-    this.lastOpenCodeSync = now;
-    const syncTimestamp = new Date().toISOString();
-    this.stateManager.setHuman({
-      ...this.stateManager.getHuman(),
-      settings: {
-        ...this.stateManager.getHuman().settings,
-        opencode: {
-          ...opencode,
-          last_sync: syncTimestamp,
-        },
-      },
-    });
-
-    this.openCodeImportInProgress = true;
-    import("../integrations/opencode/importer.js")
-      .then(({ importOpenCodeSessions }) =>
-        importOpenCodeSessions({
-          stateManager: this.stateManager,
-          interface: this.interface,
-          signal: this.importAbortController.signal,
-        })
-      )
-      .then((result) => {
-        if (result.sessionsProcessed > 0) {
-          console.log(
-            `[Processor] OpenCode sync complete: ${result.sessionsProcessed} sessions, ` +
-              `${result.messagesImported} messages imported, ` +
-              `${result.extractionScansQueued} extraction scans queued`
-          );
-        }
-      })
-      .catch((err) => {
-        console.warn(`[Processor] OpenCode sync failed:`, err);
-      })
-      .finally(() => {
-        this.openCodeImportInProgress = false;
-      });
-  }
-
-  private async checkAndSyncClaudeCode(human: HumanEntity, now: number): Promise<void> {
-    if (this.claudeCodeImportInProgress) {
-      return;
-    }
-
-    const claudeCode = human.settings?.claudeCode;
-    const pollingInterval = claudeCode?.polling_interval_ms ?? DEFAULT_CLAUDE_CODE_POLLING_MS;
-    const lastSync = claudeCode?.last_sync ? new Date(claudeCode.last_sync).getTime() : 0;
-    const timeSinceSync = now - lastSync;
-
-    if (timeSinceSync < pollingInterval && this.lastClaudeCodeSync > 0) {
-      return;
-    }
-
-    this.lastClaudeCodeSync = now;
-    const syncTimestamp = new Date().toISOString();
-    this.stateManager.setHuman({
-      ...this.stateManager.getHuman(),
-      settings: {
-        ...this.stateManager.getHuman().settings,
-        claudeCode: {
-          ...claudeCode,
-          last_sync: syncTimestamp,
-        },
-      },
-    });
-
-    this.claudeCodeImportInProgress = true;
-    import("../integrations/claude-code/importer.js")
-      .then(({ importClaudeCodeSessions }) =>
-        importClaudeCodeSessions({
-          stateManager: this.stateManager,
-          interface: this.interface,
-          signal: this.importAbortController.signal,
-        })
-      )
-      .then((result) => {
-        if (result.sessionsProcessed > 0) {
-          console.log(
-            `[Processor] Claude Code sync complete: ${result.sessionsProcessed} sessions, ` +
-              `${result.messagesImported} messages imported, ` +
-              `${result.extractionScansQueued} extraction scans queued`
-          );
-        }
-      })
-      .catch((err) => {
-        console.warn(`[Processor] Claude Code sync failed:`, err);
-      })
-      .finally(() => {
-        this.claudeCodeImportInProgress = false;
-      });
-  }
-
-  private async checkAndSyncCursor(human: HumanEntity, now: number): Promise<void> {
-    if (this.cursorImportInProgress) {
-      return;
-    }
-
-    const cursor = human.settings?.cursor;
-    const pollingInterval = cursor?.polling_interval_ms ?? DEFAULT_CURSOR_POLLING_MS;
-    const lastSync = cursor?.last_sync ? new Date(cursor.last_sync).getTime() : 0;
-    const timeSinceSync = now - lastSync;
-
-    if (timeSinceSync < pollingInterval && this.lastCursorSync > 0) {
-      return;
-    }
-
-    this.lastCursorSync = now;
-    const syncTimestamp = new Date().toISOString();
-    this.stateManager.setHuman({
-      ...this.stateManager.getHuman(),
-      settings: {
-        ...this.stateManager.getHuman().settings,
-        cursor: {
-          ...cursor,
-          last_sync: syncTimestamp,
-        },
-      },
-    });
-
-    this.cursorImportInProgress = true;
-    import("../integrations/cursor/importer.js")
-      .then(({ importCursorSessions }) =>
-        importCursorSessions({
-          stateManager: this.stateManager,
-          interface: this.interface,
-          signal: this.importAbortController.signal,
-        })
-      )
-      .then((result) => {
-        if (result.sessionsProcessed > 0) {
-          console.log(
-            `[Processor] Cursor sync complete: ${result.sessionsProcessed} sessions, ` +
-              `${result.messagesImported} messages imported, ` +
-              `${result.extractionScansQueued} extraction scans queued`
-          );
-        }
-      })
-      .catch((err) => {
-        console.warn(`[Processor] Cursor sync failed:`, err);
-      })
-      .finally(() => {
-        this.cursorImportInProgress = false;
-      });
-  }
-
-  private async checkAndSyncCodex(human: HumanEntity, now: number): Promise<void> {
-    if (this.codexImportInProgress) {
-      return;
-    }
-
-    const codex = human.settings?.codex;
-    const pollingInterval = codex?.polling_interval_ms ?? DEFAULT_CODEX_POLLING_MS;
-    const lastSync = codex?.last_sync ? new Date(codex.last_sync).getTime() : 0;
-    const timeSinceSync = now - lastSync;
-
-    if (timeSinceSync < pollingInterval && this.lastCodexSync > 0) {
-      return;
-    }
-
-    this.lastCodexSync = now;
-    const syncTimestamp = new Date().toISOString();
-    const currentHuman = this.stateManager.getHuman();
-    this.stateManager.setHuman({
-      ...currentHuman,
-      settings: {
-        ...currentHuman.settings,
-        codex: {
-          ...codex,
-          last_sync: syncTimestamp,
-        },
-      },
-    });
-
-    this.codexImportInProgress = true;
-    import("../integrations/codex/importer.js")
-      .then(({ importCodexSessions }) =>
-        importCodexSessions({
-          stateManager: this.stateManager,
-          interface: this.interface,
-          signal: this.importAbortController.signal,
-        })
-      )
-      .then((result) => {
-        if (result.sessionsProcessed > 0) {
-          console.log(
-            `[Processor] Codex sync complete: ${result.sessionsProcessed} sessions, ` +
-              `${result.messagesImported} messages imported, ` +
-              `${result.extractionScansQueued} extraction scans queued`
-          );
-        }
-      })
-      .catch((err) => {
-        console.warn(`[Processor] Codex sync failed:`, err);
-      })
-      .finally(() => {
-        this.codexImportInProgress = false;
-      });
-  }
-
-  private async checkAndSyncSlack(human: HumanEntity, now: number): Promise<void> {
-    if (this.slackImportInProgress) return;
-
-    const slack = human.settings?.slack;
-    const pollingInterval = slack?.polling_interval_ms ?? 60_000;
-
-    if (now - this.lastSlackSync < pollingInterval && this.lastSlackSync > 0) return;
-
-    this.lastSlackSync = now;
-
-    this.slackImportInProgress = true;
-    import("../integrations/slack/importer.js")
-      .then(({ importSlackChannel }) =>
-        importSlackChannel({
-          stateManager: this.stateManager,
-          interface: this.interface,
-          signal: this.importAbortController.signal,
-        })
-      )
-      .then((result) => {
-        if (result.channelProcessed) {
-          console.log(
-            `[Processor] Slack sync: #${result.channelProcessed} — ` +
-            `${result.messagesImported} messages, ${result.threadsProcessed} threads, ` +
-            `${result.scansQueued} scans queued`
-          );
-        }
-      })
-      .catch((err) => {
-        const msg = err instanceof Error ? err.message : JSON.stringify(err);
-        const stack = err instanceof Error ? err.stack : undefined;
-        console.warn(`[Processor] Slack sync failed: ${msg}${stack ? `\n${stack}` : ''}`);
-      })
-      .finally(() => {
-        this.slackImportInProgress = false;
-      });
-  }
-
-  private personaHistoryImportInProgress = false;
-
-  private async checkAndSyncPersonaHistory(_human: HumanEntity): Promise<void> {
-    if (this.personaHistoryImportInProgress) return;
-
-    this.personaHistoryImportInProgress = true;
-    import("../integrations/persona-history/importer.js")
-      .then(({ importPersonaHistory }) =>
-        importPersonaHistory({ stateManager: this.stateManager })
-      )
-      .then((result) => {
-        if (result.scansQueued > 0) {
-          console.log(
-            `[Processor] PersonaHistory: ${result.scansQueued} scans queued` +
-            (result.complete ? " — import complete" : "")
-          );
-        }
-      })
-      .catch((err) => {
-        console.warn(`[Processor] PersonaHistory sync failed:`, err);
-      })
-      .finally(() => {
-        this.personaHistoryImportInProgress = false;
-      });
-  }
-
   private augmentRoomRequest(request: LLMRequest): LLMRequest {
     if (request.next_step !== LLMNextStep.HandleRoomResponse) return request;