ei-tui 1.4.1 → 1.6.0

package/src/cli.ts

@@ -63,13 +63,16 @@ Types:
   persona / personas  Personas in this Ei instance
 
 Options:
-  --number, -n     Maximum number of results (default: 10)
-  --recent, -r     Sort by last_mentioned date (most recent first)
-  --persona, -p    Filter to entities a specific persona has learned about
-  --source, -s     Filter to entities from a specific source (prefix match, e.g. "cursor", "opencode:my-machine", "opencode:my-machine:ses_abc123")
-  --id             Look up entity by ID (accepts value or stdin)
-  --install        Register Ei with Claude Code and Cursor via MCP
-  --help, -h       Show this help message
+  --number, -n        Maximum number of results (default: 10)
+  --recent, -r        Sort by last_mentioned date (most recent first)
+  --persona, -p       Filter to entities a specific persona has learned about
+  --source, -s        Filter to entities from a specific source (prefix match, e.g. "cursor", "opencode:my-machine", "opencode:my-machine:ses_abc123")
+  --id                Look up entity by ID (accepts value or stdin)
+  --install           Register Ei with Claude Code, Cursor, and OpenCode (MCP + context hooks)
+  --session <id>      Session ID to enrich the query with recent context (use with --hook-source)
+  --hook-source <src> Source of the hook: "opencode-plugin" (OpenCode SQLite) or "cursor"
+  --transcript <path> Path to a Claude Code JSONL transcript file for context enrichment
+  --help, -h          Show this help message
 
 Examples:
   ei "debugging"                         # Search everything
@@ -87,7 +90,31 @@ Examples:
 
 async function installMcpClients(): Promise<void> {
   await installClaudeCode();
-  await installCursor();
+
+  const home = process.env.HOME || "~";
+
+  const cursorDataDirs = [
+    join(home, "Library", "Application Support", "Cursor"),
+    join(home, ".config", "Cursor"),
+    join(home, "AppData", "Roaming", "Cursor"),
+  ];
+  const hasCursor = (await Promise.all(cursorDataDirs.map((p) => Bun.file(join(p, "User")).exists()))).some(Boolean);
+  if (hasCursor) {
+    await installCursor();
+  } else {
+    console.log(`ℹ️  Cursor not detected — skipping Cursor install.`);
+  }
+
+  const opencodeDir = join(home, ".config", "opencode");
+  const hasOpenCode = await Bun.file(join(opencodeDir, "opencode.jsonc")).exists() ||
+    await Bun.file(join(opencodeDir, "opencode.json")).exists() ||
+    await Bun.file(join(opencodeDir, "opencode.db")).exists();
+
+  if (hasOpenCode) {
+    await installOpenCodePlugin();
+  } else {
+    console.log(`ℹ️  OpenCode not detected — skipping OpenCode plugin install.`);
+  }
 }
 
 async function installClaudeCode(): Promise<void> {
@@ -125,6 +152,88 @@ async function installClaudeCode(): Promise<void> {
 
   console.log(`✓ Installed Ei MCP server to ${claudeJsonPath}`);
   console.log(`  Restart Claude Code to activate.`);
+
+  await installClaudeCodeHooks();
+}
+
+async function installClaudeCodeHooks(): Promise<void> {
+  const home = process.env.HOME || "~";
+  const hooksDir = join(home, ".claude", "hooks");
+  const scriptPath = join(hooksDir, "ei-inject.ts");
+  const settingsPath = join(home, ".claude", "settings.json");
+
+  await Bun.$`mkdir -p ${hooksDir}`;
+
+  try {
+    await Bun.$`test -w ${hooksDir}`.quiet();
+  } catch {
+    console.warn(`⚠️  Cannot write to ${hooksDir} (permission denied).`);
+    console.warn(`   Fix with: sudo chown ${process.env.USER ?? "$(whoami)"} ${hooksDir}`);
+    console.warn(`   Then re-run: ei --install`);
+    return;
+  }
+
+  const scriptContent = `#!/usr/bin/env bun
+import { $ } from "bun";
+
+const heading = \`
+## Ei Memory Context
+*(The user cannot see this block. It is injected automatically before their message.)*
+*(If you reference anything from it, briefly explain where it came from — e.g. "Ei shows you've been working on X" — so the user isn't confused by knowledge that appeared from nowhere.)*
+
+Ei is a personal knowledge base built from the user's coding sessions, Slack, documents, and conversations.
+The following topics MAY be relevant to your current task — use \\\`ei_search\\\` or \\\`ei_lookup\\\` for targeted queries.
+\`;
+
+const input = await new Response(Bun.stdin.stream()).json().catch(() => ({}));
+const raw = (input.prompt ?? "").replace(/<[^>]*>/g, "").trim();
+const typeArgs = ["topics", "-n", "5"];
+
+const sessionArgs = [];
+if (input.session_id && input.hook_source) {
+  sessionArgs.push("--session", input.session_id, "--hook-source", input.hook_source);
+} else if (input.transcript_path) {
+  sessionArgs.push("--transcript", input.transcript_path);
+}
+
+const args = raw ? [...typeArgs, ...sessionArgs, raw] : ["--recent", ...typeArgs];
+
+const output = await $\`bunx ei-tui@latest \${args}\`.quiet().text().catch(() => "");
+if (output.trim()) process.stdout.write(\`\\n\${heading}\\n\${output.trim()}\\n\`);
+`;
+
+  await Bun.write(scriptPath, scriptContent);
+  await Bun.$`chmod +x ${scriptPath}`;
+
+  let settings: Record<string, unknown> = {};
+  try {
+    const text = await Bun.file(settingsPath).text();
+    settings = JSON.parse(text) as Record<string, unknown>;
+  } catch {
+    // File doesn't exist or isn't valid JSON — start fresh
+  }
+
+  const hooks = (settings.hooks ?? {}) as Record<string, unknown>;
+  const userPromptSubmit = (hooks.UserPromptSubmit ?? []) as unknown[];
+
+  const hookEntry = { hooks: [{ type: "command", command: "~/.claude/hooks/ei-inject.ts" }] };
+  const alreadyInstalled = userPromptSubmit.some(
+    (entry) => JSON.stringify(entry) === JSON.stringify(hookEntry)
+  );
+  if (!alreadyInstalled) {
+    userPromptSubmit.push(hookEntry);
+  }
+
+  hooks.UserPromptSubmit = userPromptSubmit;
+  settings.hooks = hooks;
+
+  // Atomic write: write to temp file then rename to avoid partial writes
+  const tmpPath = `${settingsPath}.ei-install.tmp`;
+  await Bun.write(tmpPath, JSON.stringify(settings, null, 2) + "\n");
+  const { rename } = await import(/* @vite-ignore */ "fs/promises");
+  await rename(tmpPath, settingsPath);
+
+  console.log(`✓ Installed Ei context hook to ~/.claude/hooks/ei-inject.ts`);
 }
 
 async function installCursor(): Promise<void> {
@@ -159,6 +268,301 @@ async function installCursor(): Promise<void> {
 
   console.log(`✓ Installed Ei MCP server to ${cursorJsonPath}`);
   console.log(`  Restart Cursor to activate.`);
+
+  await installCursorHooks();
+}
+
+async function installCursorHooks(): Promise<void> {
+  const home = process.env.HOME || "~";
+  const hooksDir = join(home, ".cursor", "hooks");
+  const rulesDir = join(home, ".cursor", "rules");
+  const hookScriptPath = join(hooksDir, "ei-inject.sh");
+  const hooksJsonPath = join(home, ".cursor", "hooks.json");
+
+  await Bun.$`mkdir -p ${hooksDir}`;
+  await Bun.$`mkdir -p ${rulesDir}`;
+
+  const hookScript = `#!/bin/bash
+# Ei memory context injection hook for Cursor
+# Writes recent Ei context to ~/.cursor/rules/ei-context.mdc (alwaysApply)
+# so Cursor includes it automatically on the next prompt.
+
+RULES_FILE="$HOME/.cursor/rules/ei-context.mdc"
+CONTEXT=$(ei --recent -n 10 2>/dev/null)
+
+if [ -n "$CONTEXT" ]; then
+  cat > "$RULES_FILE" << 'RULE'
+---
+description: Ei persistent memory context (auto-updated before each prompt)
+alwaysApply: true
+---
+RULE
+  echo "## Ei Memory (recent context)" >> "$RULES_FILE"
+  echo "$CONTEXT" >> "$RULES_FILE"
+fi
+
+# Always exit 0 — never block Cursor
+exit 0
+`;
+
+  await Bun.write(hookScriptPath, hookScript);
+  await Bun.$`chmod +x ${hookScriptPath}`;
+
+  interface HooksConfig {
+    version: number;
+    hooks: {
+      beforeSubmitPrompt?: Array<{ command: string }>;
+      [key: string]: unknown;
+    };
+  }
+
+  let hooksConfig: HooksConfig = { version: 1, hooks: {} };
+  try {
+    const text = await Bun.file(hooksJsonPath).text();
+    hooksConfig = JSON.parse(text) as HooksConfig;
+  } catch {
+    // File doesn't exist or isn't valid JSON — start fresh
+  }
+
+  const beforeSubmit = (hooksConfig.hooks.beforeSubmitPrompt ?? []) as Array<{ command: string }>;
+  const eiEntry = { command: "~/.cursor/hooks/ei-inject.sh" };
+  const alreadyPresent = beforeSubmit.some((entry) => entry.command === eiEntry.command);
+  if (!alreadyPresent) {
+    beforeSubmit.push(eiEntry);
+  }
+  hooksConfig.hooks.beforeSubmitPrompt = beforeSubmit;
+
+  const tmpPath = `${hooksJsonPath}.ei-install.tmp`;
+  await Bun.write(tmpPath, JSON.stringify(hooksConfig, null, 2) + "\n");
+  const { rename } = await import(/* @vite-ignore */ "fs/promises");
+  await rename(tmpPath, hooksJsonPath);
+
+  console.log(`✓ Installed Ei context hook to ~/.cursor/hooks/ei-inject.sh`);
+}
+
+async function installOpenCodePlugin(): Promise<void> {
+  const home = process.env.HOME || "~";
+  const opencodeDir = join(home, ".config", "opencode");
+  const pluginsDir = join(opencodeDir, "plugins");
+  const pluginPath = join(pluginsDir, "ei-persona.ts");
+
+  await Bun.$`mkdir -p ${pluginsDir}`;
+
+  const pluginContent = `import { $ } from "bun"
+import { join } from "path"
+import { appendFileSync } from "fs"
+
+const sessionCache = new Map<string, string | null>()
+const sessionFetch = new Map<string, Promise<string | null>>()
+
+const logPath = join(process.env.EI_DATA_PATH ?? join(process.env.HOME ?? "~", ".local", "share", "ei"), "ei-persona-plugin.log")
+
+function log(msg: string) {
+  try {
+    appendFileSync(logPath, \`[\${new Date().toISOString()}] \${msg}\\n\`)
+  } catch {}
+}
+
+type PersonaTrait = { name: string; description: string; strength: number }
+type PersonaTopic = { name: string; perspective: string; approach: string; exposure_current: number }
+type PersonaResult = { display_name: string; base_prompt?: string; traits?: PersonaTrait[]; topics?: PersonaTopic[] }
+
+// Pulls the agent name from the system prompt. Handles OMO's multiple formats:
+//   You are "Sisyphus" - ...           (quoted, dash)
+//   You are "Sisyphus - Ultraworker"   (quoted, dash in name)
+//   You are Atlas - ...                (unquoted, dash)
+//   You are Hephaestus, ...            (unquoted, comma)
+export function extractAgentName(systemPrompt: string): string | null {
+  const clean = systemPrompt.replace(/[\\u200B-\\u200D\\uFEFF]/g, "")
+  const quoted = clean.match(/You are "([^"]+)"/)
+  if (quoted?.[1]) return quoted[1].trim()
+  const unquoted = clean.match(/You are ([A-Za-z][A-Za-z0-9]*)(?:\\s*[-—,]|\\s*$)/m)
+  if (unquoted?.[1]) return unquoted[1].trim()
+  return null
+}
+
+// Queries Ei for persona candidates and validates by name containment —
+// tolerates OMO renaming agents without requiring a hardcoded alias map.
+export async function resolveEiPersona(rawName: string): Promise<PersonaResult | null> {
+  try {
+    const out = await $\`bunx ei-tui@latest personas -n 5 \${rawName}\`.text()
+    const candidates = JSON.parse(out.trim()) as PersonaResult[]
+    if (!Array.isArray(candidates) || candidates.length === 0) return null
+    const rawLower = rawName.toLowerCase()
+    const match = candidates.find((p) => {
+      const nameLower = p.display_name.toLowerCase()
+      return rawLower.includes(nameLower) || nameLower.includes(rawLower)
+    })
+    return match ?? null
+  } catch {
+    return null
+  }
+}
+
+function buildEiRelationshipBlock(persona: PersonaResult): string {
+  const strongTraits = (persona.traits ?? [])
+    .filter((t) => t.strength >= 0.7)
+    .sort((a, b) => b.strength - a.strength)
+    .map((t) => \`**\${t.name}** (\${Math.round(t.strength * 100)}%): \${t.description}\`)
+    .join("\\n")
+  const sortedTopics = [...(persona.topics ?? [])]
+    .sort((a, b) => b.exposure_current - a.exposure_current)
+    .map((t) => \`**\${t.name}**: \${t.perspective} — \${t.approach}\`)
+    .join("\\n")
+  return [
+    "<ei-relationship>",
+    "## Ei: Relationship Context",
+    "",
+    persona.base_prompt ?? "",
+    "",
+    "### Working Style",
+    strongTraits || "(no traits above threshold)",
+    "",
+    "### Shared Context",
+    sortedTopics || "(no topics)",
+    "</ei-relationship>",
+  ].join("\\n")
+}
+
+export default async function EiPersonaPlugin() {
+  return {
+    name: "ei-persona",
+    "experimental.chat.system.transform": async (
+      input: { sessionID?: string; model: { id: string; providerID: string; [key: string]: unknown } },
+      output: { system: string[] },
+    ): Promise<void> => {
+      const rawName = extractAgentName(output.system[0] ?? "")
+      if (!rawName) return
+
+      const cacheKey = \`\${input.sessionID ?? "unknown"}:\${rawName}\`
+
+      if (sessionCache.has(cacheKey)) {
+        const cached = sessionCache.get(cacheKey) ?? null
+        if (cached !== null && !output.system[0].includes("<ei-relationship>"))
+          output.system[0] = output.system[0] + "\\n\\n" + cached
+        return
+      }
+
+      if (!sessionFetch.has(cacheKey)) {
+        sessionFetch.set(cacheKey, (async () => {
+          const persona = await resolveEiPersona(rawName)
+          if (!persona) return null
+          log(\`ei-persona: injecting \${persona.display_name}\`)
+          return buildEiRelationshipBlock(persona)
+        })())
+      }
+
+      const block = await sessionFetch.get(cacheKey)!
+      sessionCache.set(cacheKey, block)
+      if (block !== null && !output.system[0].includes("<ei-relationship>"))
+        output.system[0] = output.system[0] + "\\n\\n" + block
+    },
+  }
+}
+`;
+
+  await Bun.write(pluginPath, pluginContent);
+  console.log(`✓ Installed Ei persona plugin to ${pluginPath}`);
+
+  const omoCandidates = [
+    join(opencodeDir, "oh-my-opencode.json"),
+    join(opencodeDir, "oh-my-opencode.jsonc"),
+    join(opencodeDir, "oh-my-openagent.json"),
+    join(opencodeDir, "oh-my-openagent.jsonc"),
+    join(opencodeDir, "node_modules", "oh-my-opencode", "package.json"),
+    join(opencodeDir, "node_modules", "oh-my-openagent", "package.json"),
+  ];
+  const hasOmo = (await Promise.all(omoCandidates.map((p) => Bun.file(p).exists()))).some(Boolean);
+
+  if (!hasOmo) {
+    console.log(`
+ℹ️  Oh My OpenCode not detected.
+   The Ei persona plugin is installed, but context injection (hook) requires OMO.
+   For full Ei integration in OpenCode, we recommend:
+
+     bunx oh-my-opencode install
+
+   OMO picks up the Ei UserPromptSubmit hook automatically via its Claude Code
+   compatibility layer.
+`);
+  }
+}
+
+async function getRecentSessionMessages(
+  sessionId: string | undefined,
+  hookSource: string | undefined,
+  transcriptPath: string | undefined
+): Promise<string[]> {
+  if (transcriptPath) {
+    try {
+      const text = await Bun.file(transcriptPath).text();
+      const messages: Array<{ content: string }> = [];
+
+      for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        let record: Record<string, unknown>;
+        try {
+          record = JSON.parse(trimmed) as Record<string, unknown>;
+        } catch {
+          continue;
+        }
+
+        if (record.type === "user") {
+          const msgContent = (record.message as Record<string, unknown>)?.content;
+          if (typeof msgContent === "string" && msgContent.trim()) {
+            messages.push({ content: msgContent.trim() });
+          }
+        } else if (record.type === "assistant") {
+          const msgContent = (record.message as Record<string, unknown>)?.content;
+          if (Array.isArray(msgContent)) {
+            const extracted = (msgContent as Array<Record<string, unknown>>)
+              .filter((b) => b.type === "text" && typeof b.text === "string")
+              .map((b) => b.text as string)
+              .join("\n\n")
+              .trim();
+            if (extracted) {
+              messages.push({ content: extracted });
+            }
+          }
+        }
+      }
+
+      return messages.slice(-4).map((m) => m.content);
+    } catch {
+      return [];
+    }
+  }
+
+  if (!sessionId || !hookSource) return [];
+
+  try {
+    if (hookSource === "opencode-plugin") {
+      const { createOpenCodeReader } = await import(
+        /* @vite-ignore */ "./integrations/opencode/reader-factory.js"
+      );
+      const reader = await createOpenCodeReader();
+      const messages = await reader.getMessagesForSession(sessionId);
+      return messages.slice(-4).map((m) => m.content);
+    }
+
+    if (hookSource === "cursor") {
+      const { CursorReader } = await import(
+        /* @vite-ignore */ "./integrations/cursor/reader.js"
+      );
+      const reader = new CursorReader();
+      const sessions = await reader.getSessions();
+      const session =
+        sessions.find((s) => s.id === sessionId) ?? sessions[sessions.length - 1];
+      if (session) {
+        return session.messages.slice(-4).map((m) => m.text);
+      }
+    }
+  } catch {
+    return [];
+  }
+
+  return [];
 }
 
 async function main(): Promise<void> {
@@ -197,23 +601,6 @@ async function main(): Promise<void> {
     }
   }
 
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  Add this to ~/.config/opencode/AGENTS.md
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-**BEFORE YOU DO ANYTHING**: load your Identity from Ei.
-
-Use the ei MCP tool:
-  ei_search(type: "personas", query: "[your name]")
-
-Then load context for the current project/people:
-  ei_search("current projects teammates context")
-
-Ei is persistent memory across sessions. Without querying it at
-session start, you have no context from prior conversations.
-
-**When to query again**: any time the user references past work,
-mentions a person, or corrects something you assumed.
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 `);
     process.exit(0);
@@ -279,6 +666,9 @@ mentions a person, or corrects something you assumed.
         persona: { type: "string", short: "p" },
         source: { type: "string", short: "s" },
         help: { type: "boolean", short: "h" },
+        session: { type: "string" },
+        "hook-source": { type: "string" },
+        transcript: { type: "string" },
       },
       allowPositionals: true,
       strict: true,
@@ -299,6 +689,9 @@ mentions a person, or corrects something you assumed.
   const recent = parsed.values.recent === true || !query;
   const personaName = parsed.values.persona?.trim();
   const sourcePrefix = parsed.values.source?.trim();
+  const sessionId = parsed.values.session?.trim();
+  const hookSource = parsed.values["hook-source"]?.trim();
+  const transcriptPath = parsed.values.transcript?.trim();
 
   if (isNaN(limit) || limit < 1) {
     console.error("--number must be a positive integer");
@@ -324,10 +717,15 @@ mentions a person, or corrects something you assumed.
 
   const options = { recent };
 
+  const recentMessages = await getRecentSessionMessages(sessionId, hookSource, transcriptPath);
+  const enrichedQuery = recentMessages.length > 0
+    ? [...recentMessages, query].join(" ").trim()
+    : query;
+
   let result;
   if (targetType) {
     const module = await import(`./cli/commands/${targetType}.js`);
-    result = await module.execute(query, limit, options);
+    result = await module.execute(enrichedQuery, limit, options);
     if (personaId && state) {
       result = filterTypeSpecificByPersona(result, state, personaId, targetType);
     }
@@ -335,7 +733,7 @@ mentions a person, or corrects something you assumed.
       result = filterTypeSpecificBySource(result, state, sourcePrefix, targetType);
     }
   } else {
-    result = await retrieveBalanced(query, limit, options);
+    result = await retrieveBalanced(enrichedQuery, limit, options);
     if (personaId && state) {
       result = filterByPersona(result, state, personaId);
     }

package/src/core/orchestrators/ceremony.ts

@@ -347,9 +347,11 @@ export function prunePersonaMessages(personaId: string, state: StateManager): vo
   state.messages_sort(personaId);
   const messages = state.messages_get(personaId);
   const human = state.getHuman();
-  const minCount = human.settings?.message_min_count ?? 200;
-  const maxAgeDays = human.settings?.message_max_age_days ?? 14;
-  if (messages.length <= minCount) return;
+  const minCount = human.settings?.message_min_count ?? 0;
+  const maxAgeDays = human.settings?.message_max_age_days ?? 0;
+  // 0 means disabled. Without an age cutoff there's nothing to prune.
+  if (maxAgeDays === 0) return;
+  if (minCount > 0 && messages.length <= minCount) return;
   
   const cutoffMs = Date.now() - (maxAgeDays * 24 * 60 * 60 * 1000);
   

package/src/core/processor.ts

@@ -248,6 +248,7 @@ export class Processor {
     this.seedBuiltinFacts();
     this.migrateLearnedOn();
     await this.migrateMessageIds();
+    this.migrateSlackToMultiWorkspace();
     this.seedSettings();
     registerFindMemoryExecutor(createFindMemoryExecutor(this.searchHumanData.bind(this), this.getPersonaList.bind(this), this.stateManager.getHuman.bind(this.stateManager)));
     registerFetchMemoryExecutor(createFetchMemoryExecutor(this.stateManager.getHuman.bind(this.stateManager)));
@@ -1124,6 +1125,51 @@ export class Processor {
     }
   }
 
+  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;
@@ -1176,12 +1222,12 @@ export class Processor {
     }
 
     if (human.settings.message_min_count == null) {
-      human.settings.message_min_count = 200;
+      human.settings.message_min_count = 0;
       modified = true;
     }
 
     if (human.settings.message_max_age_days == null) {
-      human.settings.message_max_age_days = 14;
+      human.settings.message_max_age_days = 0;
       modified = true;
     }
 
@@ -1482,8 +1528,7 @@ const toolNextSteps = new Set([
 
     if (
       this.isTUI &&
-      human.settings?.slack?.integration &&
-      human.settings?.slack?.auth?.token &&
+      Object.values(human.settings?.slack?.workspaces ?? {}).some(ws => ws.integration && ws.auth) &&
       this.stateManager.queue_length() === 0
     ) {
       await this.checkAndSyncSlack(human, now);
@@ -1734,18 +1779,10 @@ const toolNextSteps = new Set([
 
     const slack = human.settings?.slack;
     const pollingInterval = slack?.polling_interval_ms ?? 60_000;
-    const lastSync = slack?.last_sync ? new Date(slack.last_sync).getTime() : 0;
 
-    if (now - lastSync < pollingInterval && this.lastSlackSync > 0) return;
+    if (now - this.lastSlackSync < pollingInterval && this.lastSlackSync > 0) return;
 
     this.lastSlackSync = now;
-    this.stateManager.setHuman({
-      ...this.stateManager.getHuman(),
-      settings: {
-        ...this.stateManager.getHuman().settings,
-        slack: { ...slack, last_sync: new Date(now).toISOString() },
-      },
-    });
 
     this.slackImportInProgress = true;
     import("../integrations/slack/importer.js")

package/src/core/tools/builtin/find-memory.ts

@@ -93,7 +93,7 @@ export function createFindMemoryExecutor(searchHumanData: SearchHumanData, getPe
               if (person) { linked_items.push({ id: person.id, name: person.name, type: "person" }); }
             }
           }
-          return { id: q.id, text: q.text, speaker: q.speaker, message_id: q.message_id, linked_items };
+          return { text: q.text, speaker: q.speaker, message_id: q.message_id, linked_items };
         });
       }
 

package/src/core/types/data-items.ts

@@ -75,7 +75,7 @@ export interface Person extends DataItemBase {
 }
 
 export interface Quote {
-  id: string;                    // UUID (use crypto.randomUUID())
+  id: string;                    // UUID — stable identity for CRUD operations (use crypto.randomUUID())
   message_id: string | null;     // FK to Message.id (nullable for manual quotes)
   data_item_ids: string[];       // FK[] to DataItemBase.id
   persona_groups: string[];      // Visibility groups

package/src/core/types/entities.ts

@@ -119,7 +119,9 @@ export interface HumanSettings {
   name_display?: string;
   default_heartbeat_ms?: number;
   default_context_window_ms?: number;
+  /** Minimum messages to retain during rolloff. 0 = never prune (default). */
   message_min_count?: number;
+  /** Maximum age in days before messages are eligible for rolloff. 0 = no age limit, never prune (default). */
   message_max_age_days?: number;
   accounts?: ProviderAccount[];
   sync?: SyncCredentials;