ei-tui 1.4.1 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ei-tui",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "author": "Flare576",
   "repository": {
     "type": "git",

package/src/cli/README.md

@@ -37,7 +37,7 @@ ei --id "claudecode:my-machine:session-uuid:message-uuid"
 ei --id "cursor:my-machine:composer-uuid:bubble-uuid"
 ```
 
-Quotes surfaced by `ei_search` or `ei_find_memory` include a `message_id` field in this format — pipe it to `ei --id` to read the original conversation.
+Quotes surfaced by `ei_search` include a `message_id` field in this format — pipe it to `ei --id` to read the original conversation.
 
 # OpenCode Integration
 
@@ -47,12 +47,15 @@ Quotes surfaced by `ei_search` or `ei_find_memory` include a `message_id` field
 ei --install
 ```
 
-This registers Ei with Claude Code and Cursor via MCP:
+This registers Ei with Claude Code, Cursor, and OpenCode — MCP server config **and** context injection hooks so agents get Ei memory automatically without needing to call a tool:
 
-- **Claude Code**: writes `~/.claude.json` with an MCP server entry
-- **Cursor**: writes `~/.cursor/mcp.json` with an MCP server entry
+| Tool | MCP | Context Hook |
+|------|-----|-------------|
+| **Claude Code** | `~/.claude.json` | `~/.claude/settings.json` (`UserPromptSubmit`) + `~/.claude/hooks/ei-inject.ts` |
+| **Cursor** | `~/.cursor/mcp.json` | `~/.cursor/hooks.json` (`beforeSubmitPrompt`) + `~/.cursor/hooks/ei-inject.sh` |
+| **OpenCode** | manual (see below) | Detected automatically via Oh My OpenCode compatibility layer (reads `~/.claude/settings.json`) |
 
-**OpenCode**: add the MCP server manually to `~/.config/opencode/opencode.jsonc`:
+**OpenCode MCP**: add manually to `~/.config/opencode/opencode.jsonc`:
 
 ```json
 {
@@ -81,28 +84,20 @@ ei mcp
 
 ## Activating Ei in Your Agent
 
-`ei --install` handles the technical wiring. This step tells your agent *when* and *how* to reach for it.
+`ei --install` handles both the technical wiring **and** context injection. After running it, your agent will automatically receive recent Ei memory before every message — no tool calls required.
 
-Without this, your agent has Ei available but may never call it. Add a snippet to your tool's config and it'll start querying Ei at the start of each session — and whenever you reference past context.
+The snippets below are optional manual overrides if you want to customize the behavior or add targeted mid-session queries.
 
 ### OpenCode
 
-Add to `~/.config/opencode/AGENTS.md` (applies to all projects):
+If you're using [Oh My OpenCode](https://github.com/code-yeongyu/oh-my-opencode), the `UserPromptSubmit` hook installed by `ei --install` is picked up automatically via its Claude Code compatibility layer — no additional config needed.
+
+If you're running vanilla OpenCode without Oh My OpenCode, add to `~/.config/opencode/AGENTS.md`:
 
 ```markdown
-At session start, query Ei for user context:
-
-\```bash
-ei "What are the user's current preferences, active projects, and workflow?"
-\```
-
-Ei is a persistent knowledge base built from the user's conversations — facts, preferences,
-people, topics, personas. Use it when the user references past work, mentions how they like things done,
-asks "how did we do X," or needs to look up a person by any name, handle, or account (GitHub username,
-Discord handle, email, nickname, etc.) — people results include an `identifiers` array covering all
-known accounts and aliases for that person. Use `ei --persona "Beta" "walruses"` to scope results to
-what a specific persona has learned. Use `ei personas "name"` to find personas by name. Query again
-mid-session when they correct you or reference something from a previous session.
+Use the **ei** MCP to pull user context when the user references past work, mentions people
+or preferences, or asks "how did we do X." Call `ei_search` with a natural-language query.
+Use `ei --persona "Beta" "topic"` to scope results to what a specific persona has learned.
 ```
 
 ### Claude Code
@@ -149,9 +144,8 @@ conversations (facts, people, topics, quotes, personas).
 
 **How to use:**
 1. Call `ei_search` (server `user-ei`) with a natural-language query (or omit query and use `recent: true` to browse); optionally filter by `type` (facts, people, topics, quotes, personas) or `persona` display_name.
-2. If you need full detail for a human entity (fact, topic, person, quote), call `ei_fetch_memory` with the entity `id`.
-3. If you need full detail for a result including personas, call `ei_lookup` with the entity `id` from step 1.
-4. To fetch a specific message with surrounding context, call `ei_fetch_message` with the message `id` and optional `before`/`after` counts.
+2. If you need the full record for any result, call `ei_lookup` with the entity `id` from step 1 — works for all types including personas.
+3. If a quote result has a `message_id`, call `ei_fetch_message` with that ID and optional `before`/`after` counts to read the original conversation with context.
 
 Prefer querying Ei before asking the user for context they may have already shared.
 ```
@@ -162,20 +156,18 @@ The MCP server exposes these tools to Claude Code, Cursor, and OpenCode:
 
 | Tool | Description |
 |------|-------------|
-| `ei_search` | Balanced search across all five data types (facts, topics, people, quotes, personas). Supports `type`, `persona`, `source`, `recent`, `limit` filters. |
-| `ei_lookup` | Full-record lookup for any entity by ID (facts, topics, people, quotes, personas). |
-| `ei_find_memory` | Grouped human-data search — facts, topics, people, quotes. Returns results grouped by type. Mirrors the persona `find_memory` tool interface. |
-| `ei_fetch_memory` | Full-record lookup for a human entity (Fact, Topic, Person, or Quote) by ID. Returns the complete record including all fields. |
-| `ei_fetch_message` | Retrieve a specific message by fully-qualified ID with optional `before`/`after` context window. Routes to the correct source: `ei:uuid` searches Ei state, `opencode:machine:session:id` queries the OpenCode SQLite DB, `claudecode:...` scans Claude Code JSONL files, `cursor:...` reads the Cursor global DB. Returns message content, surrounding context, and session metadata. |
+| `ei_search` | Search across all five data types (facts, topics, people, quotes, personas). Supports `type`, `persona`, `source`, `recent`, `limit` filters. Start here. |
+| `ei_lookup` | Full-record lookup for any entity by ID — facts, topics, people, quotes, or personas. Use when you need complete details beyond the search summary. |
+| `ei_fetch_message` | Retrieve a specific message by fully-qualified ID with optional `before`/`after` context window. Use when a quote result has a `message_id` and you want the original conversation. Routes to the correct source automatically. |
 
-### `ei_search` / `ei_find_memory` arguments
+### `ei_search` arguments
 
 | Arg | Type | Description |
 |-----|------|-------------|
 | `query` | string (optional) | Search text. Omit to browse by recency. |
+| `type` | enum (optional) | `facts` \| `people` \| `topics` \| `quotes` \| `personas` — omit for balanced results across all types |
 | `persona` | string (optional) | Persona display_name to scope results to what that persona has learned |
-| `type` | enum (optional, `ei_search` only) | `facts` \| `people` \| `topics` \| `quotes` \| `personas` — omit for balanced results |
-| `types` | array (optional, `ei_find_memory` only) | `["facts", "topics", "people", "quotes"]` — omit for all human types |
+| `source` | string (optional) | Prefix match against source identifiers (e.g. `opencode`, `cursor:my-machine`) |
 | `limit` | number (optional) | Max results, default 10 |
 | `recent` | boolean (optional) | Sort by most recently mentioned instead of relevance |
 
@@ -187,7 +179,7 @@ All search commands return arrays. Each result includes a `type` field.
 
 **Person**: `{ type, id, name, description, relationship, sentiment, identifiers[] }` — `identifiers` contains all known accounts and aliases (e.g. `{ type: "GitHub", value: "flare576" }`)
 
-**Quote**: `{ type, id, text, speaker, timestamp, linked_items[] }`
+**Quote**: `{ type, text, speaker, message_id, timestamp, linked_items[] }` — note: `id` is intentionally omitted; use `message_id` with `ei_fetch_message` to retrieve the original conversation
 
 **Persona**: `{ type, id, display_name, short_description, model, base_prompt, traits[], topics[] }`
 

package/src/cli/mcp.ts

@@ -18,7 +18,7 @@ export function createMcpServer(): McpServer {
     "ei_search",
     {
       description:
-        "Search the user's Ei knowledge base — a persistent memory store built from conversations. Returns facts, people, topics of interest, quotes, and personas. People results include an identifiers array (e.g. GitHub username, Discord handle, email, nickname) — query by any name or handle to find what Ei knows about that person. Persona results include traits and topics that define the persona's identity and working style — use type='personas' with the persona's name OR a natural-language description of what they do to load a persona's character sheet. Results include entity IDs that can be passed back to ei_lookup for full detail. Omit query to browse by recency (use with recent=true or persona filter).",
+        "Search the user's Ei knowledge base — a persistent memory store built from conversations. Use at session start to load user context, and mid-session whenever the user references past work, preferences, or people. Returns facts, people, topics of interest, quotes, and personas. TYPE GUIDANCE: 'facts' are ONLY user demographics (name, age, job title, location, family structure, physical traits). For interests, opinions, hobbies, or anything the human cares about, use 'topics'. For named individuals, use 'people'. For verbatim things said, use 'quotes'. For AI agent identities with traits and working style, use 'personas'. People results include an identifiers array (e.g. GitHub username, Discord handle, email, nickname) — query by any name or handle to find what Ei knows about that person. Persona results include traits and topics — use type='personas' with the persona's name OR a natural-language description of their role to load a persona's character sheet. Results include entity IDs that can be passed to ei_lookup for full detail. Omit query with recent=true to browse the most recently discussed items.",
       inputSchema: {
         query: z.string().optional().describe("Search text. Supports natural language. Omit to browse without semantic filtering — useful with recent=true or persona filter."),
         type: z
@@ -99,7 +99,7 @@ export function createMcpServer(): McpServer {
     "ei_lookup",
     {
       description:
-        "Look up a specific entity in the Ei knowledge base by ID. Returns the full entity record. Use IDs from ei_search results.",
+        "Retrieve the full record for any Ei entity by ID — facts, topics, people, quotes, or personas. Use when ei_search returns an item and you need its complete details (all fields, traits, topics, identifiers, etc.). Pass the entity id from ei_search results.",
       inputSchema: {
         id: z.string().describe("The entity ID to look up."),
         source: z
@@ -130,131 +130,11 @@ export function createMcpServer(): McpServer {
     }
   );
 
-  server.registerTool(
-    "ei_find_memory",
-    {
-      description:
-        "Search Ei's persistent knowledge base — facts, topics, people, and quotes learned across ALL conversations over time. Use when you need context about the user, their life, relationships, or interests that may not be visible in the current exchange. Returns results grouped by type. Use `recent: true` to retrieve what's been discussed recently. TYPE GUIDANCE: 'facts' are ONLY user demographics — name, age, job title, location, family structure, physical traits. For interests, opinions, hobbies, or anything the human cares about, use 'topics'. For named individuals, use 'people'. For verbatim things said, use 'quotes'.",
-      inputSchema: {
-        query: z
-          .string()
-          .optional()
-          .describe(
-            "What to search for — a person, topic, fact, or anything Ei has learned about the user. Omit with recent: true to browse recent items."
-          ),
-        types: z
-          .array(z.enum(["facts", "topics", "people", "quotes"]))
-          .optional()
-          .describe("Limit search to specific memory types (default: all types). Use 'facts' ONLY for user demographics (name, age, job, location, family). Use 'topics' for interests, opinions, and anything the human cares about."),
-        limit: z
-          .number()
-          .optional()
-          .default(10)
-          .describe("Max results per type to return (default: 10, max: 20)"),
-        recent: z
-          .boolean()
-          .optional()
-          .describe(
-            "If true, return recently-mentioned results sorted by last_mentioned date instead of relevance. Combine with a query to filter recent results by topic."
-          ),
-        persona: z
-          .string()
-          .optional()
-          .describe(
-            "Filter results to what a specific persona has learned. Use the persona display name."
-          ),
-      },
-    },
-    async ({ query: rawQuery, types, limit, recent, persona }) => {
-      const query = rawQuery ?? "";
-      const effectiveLimit = Math.min(limit ?? 10, 20);
-      const options = { recent: recent ?? false };
-
-      const humanTypes = ["facts", "topics", "people", "quotes"] as const;
-      type HumanType = (typeof humanTypes)[number];
-      const requestedTypes: HumanType[] =
-        types && types.length > 0
-          ? (types as HumanType[])
-          : [...humanTypes];
-
-      let state: StorageState | null = null;
-      let personaId: string | undefined;
-      if (persona) {
-        state = await loadLatestState();
-        if (state) {
-          personaId = resolvePersonaId(state, persona) ?? undefined;
-          if (!personaId) {
-            return {
-              content: [{ type: "text" as const, text: `Persona "${persona}" not found.` }],
-            };
-          }
-        }
-      }
-
-      const grouped: Record<string, unknown[]> = {};
-      for (const t of requestedTypes) {
-        const module = await import(`./commands/${t}.js`);
-        let results = await (
-          module.execute as (
-            q: string,
-            l: number,
-            o: { recent: boolean }
-          ) => Promise<{ id: string }[]>
-        )(query, effectiveLimit, options);
-        if (personaId && state) {
-          results = filterTypeSpecificByPersona(results, state, personaId, t);
-        }
-        if (results.length > 0) {
-          grouped[t] = results;
-        }
-      }
-
-      if (Object.keys(grouped).length === 0) {
-        return {
-          content: [
-            {
-              type: "text" as const,
-              text: JSON.stringify({ result: "No relevant memories found for this query." }),
-            },
-          ],
-        };
-      }
-
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify(grouped, null, 2) }],
-      };
-    }
-  );
-
-  server.registerTool(
-    "ei_fetch_memory",
-    {
-      description:
-        "Retrieve the full record for a specific memory by its ID. Use when ei_find_memory or ei_search returns an item and you need its complete details. Returns the full Fact, Topic, Person, or Quote record.",
-      inputSchema: {
-        id: z.string().describe("The ID of the memory record to retrieve"),
-      },
-    },
-    async ({ id }) => {
-      const result = await lookupById(id);
-
-      if (result === null || result.type === "persona") {
-        return {
-          content: [{ type: "text" as const, text: `No memory record found with ID: ${id}` }],
-        };
-      }
-
-      return {
-        content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
-      };
-    }
-  );
-
   server.registerTool(
     "ei_fetch_message",
     {
       description:
-        "Retrieve a specific message by its ID, with optional surrounding context. Use when ei_find_memory returns a quote with a message_id and you want to read the original conversation. The 'before' and 'after' parameters return that many additional messages for context (default 0).",
+        "Retrieve a specific message by its fully-qualified ID, with optional surrounding conversation context. Use when ei_search returns a quote with a message_id and you want to read the original exchange. The 'before' and 'after' parameters expand the context window in either direction (default 0). Accepts IDs from any integrated source: 'ei:uuid' searches Ei state, 'opencode:machine:session:id' queries OpenCode SQLite, 'claudecode:...' scans Claude Code JSONL files, 'cursor:...' reads the Cursor DB.",
       inputSchema: {
         id: z.string().describe("The ID of the message to retrieve"),
         before: z

package/src/cli/retrieval.ts

@@ -84,7 +84,6 @@ export interface LinkedItem {
   type: string;
 }
 export interface QuoteResult {
-  id: string;
   text: string;
   speaker: string;
   timestamp: string;
@@ -163,7 +162,6 @@ export function resolveLinkedItems(dataItemIds: string[], state: StorageState):
 }
 export function mapQuote(quote: Quote, state: StorageState): QuoteResult {
   return {
-    id: quote.id,
     text: quote.text,
     speaker: quote.speaker,
     timestamp: quote.timestamp,
@@ -287,16 +285,11 @@ export async function retrieveBalanced(
   const recentDate = (item: AnyItem): string => item.last_mentioned ?? item.last_updated ?? "";
 
   if (recent && !query) {
-    const allItems: Array<{ type: DataType; item: AnyItem; mapped: QuoteResult | FactResult | PersonResult | TopicResult | PersonaResult }> = [
+    const allItems: Array<{ type: DataType; item: AnyItem; mapped: QuoteResult | FactResult | PersonResult | TopicResult }> = [
       ...state.human.quotes.map(q => ({ type: "quote" as DataType, item: q as AnyItem, mapped: mapQuote(q, state) })),
       ...state.human.facts.map(f => ({ type: "fact" as DataType, item: f as AnyItem, mapped: mapFact(f) })),
       ...state.human.people.map(p => ({ type: "person" as DataType, item: p as AnyItem, mapped: mapPerson(p) })),
       ...state.human.topics.map(t => ({ type: "topic" as DataType, item: t as AnyItem, mapped: mapTopic(t) })),
-      ...Object.values(state.personas).map(({ entity: p }) => ({
-        type: "persona" as DataType,
-        item: { id: p.id, last_updated: p.last_updated } as AnyItem,
-        mapped: mapPersona(p),
-      })),
     ];
     return allItems
       .sort((a, b) => recentDate(b.item).localeCompare(recentDate(a.item)))
@@ -330,22 +323,10 @@ export async function retrieveBalanced(
         }
       }
     }
-    const embeddingResults = allScored
+    return allScored
       .sort((a, b) => recentDate(b.mapped as AnyItem).localeCompare(recentDate(a.mapped as AnyItem)))
       .slice(0, limit)
       .map(({ type, mapped }) => ({ type, ...mapped }) as BalancedResult);
-    const personaMatches = [
-      ...retrievePersonas(query, state, limit, { recent: true }),
-      ...await retrievePersonasSemantic(queryVector, state, limit),
-    ].filter((p, i, arr) => arr.findIndex(x => x.id === p.id) === i);
-    if (personaMatches.length > 0) {
-      const combined = [
-        ...personaMatches.map((p) => ({ type: "persona" as const, ...p }) as BalancedResult),
-        ...embeddingResults,
-      ];
-      return combined.slice(0, limit);
-    }
-    return embeddingResults;
   }
 
   for (const { type, items, mapper } of typeConfigs) {
@@ -383,19 +364,7 @@ export async function retrieveBalanced(
 
   result.sort((a, b) => b.similarity - a.similarity);
 
-  const embeddingFinal = result.map(({ type, mapped }) => ({ type, ...mapped }) as BalancedResult);
-  const personaFinal = [
-    ...retrievePersonas(query, state, limit),
-    ...await retrievePersonasSemantic(queryVector, state, limit),
-  ].filter((p, i, arr) => arr.findIndex(x => x.id === p.id) === i);
-  if (personaFinal.length > 0) {
-    const combined = [
-      ...personaFinal.map((p) => ({ type: "persona" as const, ...p }) as BalancedResult),
-      ...embeddingFinal,
-    ];
-    return combined.slice(0, limit);
-  }
-  return embeddingFinal;
+  return result.map(({ type, mapped }) => ({ type, ...mapped }) as BalancedResult);
 }
 
 const OPENCODE_MESSAGE_ID = /^msg_[a-zA-Z0-9]+$/;

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
@@ -88,6 +91,7 @@ Examples:
 async function installMcpClients(): Promise<void> {
   await installClaudeCode();
   await installCursor();
+  await installOpenCodePlugin();
 }
 
 async function installClaudeCode(): Promise<void> {
@@ -125,6 +129,87 @@ 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
+
+Ei is a personal knowledge base built from coding sessions, Slack, documents, and conversations.
+The following topics MAY be relevant to your current task — use the \\\`ei_search\\\` and \\\`ei_lookup\\\`
+MCP tools 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 +244,184 @@ 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 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 detected — UserPromptSubmit hook covers OpenCode automatically.`);
+    return;
+  }
+
+  console.log(`
+ℹ️  OpenCode detected without Oh My OpenCode.
+   The ~/.claude/settings.json UserPromptSubmit hook only fires in Claude Code.
+   For the same context injection in OpenCode, we recommend:
+
+     bunx oh-my-opencode install
+
+   Oh My OpenCode is to OpenCode what oh-my-zsh is to zsh — you can run
+   without it, but you probably shouldn't. It also picks up the Ei 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 +460,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 +525,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 +548,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 +576,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 +592,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,6 +75,7 @@ export interface Person extends DataItemBase {
 }
 
 export interface Quote {
+  /** @deprecated Remove in v1.6 — use message_id for retrieval */
   id: string;                    // UUID (use crypto.randomUUID())
   message_id: string | null;     // FK to Message.id (nullable for manual quotes)
   data_item_ids: string[];       // FK[] to DataItemBase.id

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;

package/src/integrations/slack/importer.ts

@@ -3,11 +3,12 @@ import type { Ei_Interface, Message, PersonaEntity, Person } from "../../core/ty
 import type { PersonIdentifier } from "../../core/types/data-items.js";
 import { ContextStatus } from "../../core/types/enums.js";
 import { queueAllScans, queuePersonScan, queuePersonUpdate, type ExtractionContext } from "../../core/orchestrators/human-extraction.js";
+import { queueTopicRewritePhase } from "../../core/orchestrators/ceremony.js";
 import type { ItemMatchResult } from "../../prompts/human/types.js";
 import { qualifySlackMessage } from "../../core/utils/message-id.js";
 import { SLACK_PERSONA_DEFINITION } from "../../templates/slack.js";
 import { SlackReader, SlackRateLimitError, type ResolvedMessage } from "./reader.js";
-import type { SlackChannelState } from "./types.js";
+import type { SlackChannelState, SlackWorkspaceConfig } from "./types.js";
 
 const SLACK_USER_ID_KEY = "Slack User ID";
 const WINDOW_MS = 24 * 60 * 60 * 1000;
@@ -170,10 +171,19 @@ export async function importSlackChannel(opts: {
 
   const human = stateManager.getHuman();
   const slackSettings = human.settings?.slack;
-  if (!slackSettings?.auth?.token) return result;
+  const workspaces = slackSettings?.workspaces ?? {};
+
+  // Find the workspace with the oldest unprocessed channel that has integration enabled
+  const enabledWorkspaces = Object.entries(workspaces).filter(([, ws]) => ws.integration);
+  if (enabledWorkspaces.length === 0) return result;
+
+  // We'll pick the right workspace after channel discovery — for now grab the first enabled one
+  // to bootstrap the reader. Multi-workspace candidate selection happens below.
+  // TODO: proper cross-workspace oldest-channel selection in a future pass
+  const [workspaceId, workspaceConfig] = enabledWorkspaces[0] as [string, SlackWorkspaceConfig];
 
   const persona = ensureSlackPersona(stateManager, opts.interface);
-  const reader = new SlackReader(slackSettings.auth.token);
+  const reader = new SlackReader(workspaceConfig.auth);
 
   // Seed caches from known people identifiers
   for (const person of human.people) {
@@ -190,15 +200,13 @@ export async function importSlackChannel(opts: {
   if (signal?.aborted) return result;
 
   let channels = await reader.listChannels();
-  const channelStates: Record<string, SlackChannelState> = { ...slackSettings.channels };
+  const channelStates: Record<string, SlackChannelState> = { ...workspaceConfig.channels };
 
   // Seed channel name cache from saved state
   for (const [id, state] of Object.entries(channelStates)) {
     if (state.name) reader.seedChannelCache(id, state.name);
   }
 
-  const workspaceId = slackSettings.auth?.workspace_id ?? "unknown";
-
   // Loop through candidate channels until we find one with messages to process,
   // or exhaust all candidates. Empty channels are marked caught up and skipped
   // so the next cycle doesn't re-examine them.
@@ -214,7 +222,7 @@ export async function importSlackChannel(opts: {
   while (true) {
     if (signal?.aborted) return result;
 
-    const candidate = reader.selectCandidateChannel(channels, channelStates, slackSettings, now);
+    const candidate = reader.selectCandidateChannel(channels, channelStates, workspaceConfig, now);
     if (!candidate) return result; // all channels caught up
 
     const { channel, state } = candidate;
@@ -228,7 +236,7 @@ export async function importSlackChannel(opts: {
     channelName = updatedState.name ?? channelId;
     reader.seedChannelCache(channelId, channelName);
 
-    const extractionPointMs = new Date(channelState.extraction_point ?? new Date(nowMs - (slackSettings.backfill_days?.public ?? 30) * 86400_000).toISOString()).getTime();
+    const extractionPointMs = new Date(channelState.extraction_point ?? new Date(nowMs - (workspaceConfig.backfill_days?.public ?? 30) * 86400_000).toISOString()).getTime();
     const extractionPointTs = (extractionPointMs / 1000).toFixed(6);
 
     // Probe for the next actual message — skips silent periods instantly
@@ -256,7 +264,13 @@ export async function importSlackChannel(opts: {
           ...updatedHuman.settings,
           slack: {
             ...updatedHuman.settings?.slack,
-            channels: { ...updatedHuman.settings?.slack?.channels, [channelId]: updatedState },
+            workspaces: {
+              ...updatedHuman.settings?.slack?.workspaces,
+              [workspaceId]: {
+                ...workspaceConfig,
+                channels: { ...workspaceConfig.channels, [channelId]: updatedState },
+              },
+            },
           },
         },
       });
@@ -323,7 +337,7 @@ export async function importSlackChannel(opts: {
       sourceTag,
       workspaceId,
       stateManager,
-      slackSettings.extraction_model,
+      workspaceConfig.extraction_model,
     );
   }
 
@@ -347,7 +361,7 @@ export async function importSlackChannel(opts: {
       result.scansQueued += queueScansForMessages(
         contextMsgs, analyzeMsgs, participants,
         persona.id, channelName, sourceTag, workspaceId,
-        stateManager, slackSettings.extraction_model,
+        stateManager, workspaceConfig.extraction_model,
       );
     }
 
@@ -375,7 +389,7 @@ export async function importSlackChannel(opts: {
       result.scansQueued += queueScansForMessages(
         contextMsgs, analyzeMsgs, participants,
         persona.id, channelName, sourceTag, workspaceId,
-        stateManager, slackSettings.extraction_model,
+        stateManager, workspaceConfig.extraction_model,
       );
     }
 
@@ -395,14 +409,21 @@ export async function importSlackChannel(opts: {
       ...updatedHuman.settings,
       slack: {
         ...updatedHuman.settings?.slack,
-        channels: {
-          ...updatedHuman.settings?.slack?.channels,
-          [channelId]: updatedState,
+        workspaces: {
+          ...updatedHuman.settings?.slack?.workspaces,
+          [workspaceId]: {
+            ...workspaceConfig,
+            channels: { ...workspaceConfig.channels, [channelId]: updatedState },
+          },
         },
       },
     },
   });
 
+  if (result.messagesImported > 0) {
+    queueTopicRewritePhase(stateManager);
+  }
+
   result.channelProcessed = channelName;
   return result;
 }

package/src/integrations/slack/reader.ts

@@ -1,4 +1,4 @@
-import type { SlackChannelState, SlackSettings } from "./types.js";
+import type { SlackAuth, SlackChannelState, SlackWorkspaceConfig } from "./types.js";
 
 export class SlackRateLimitError extends Error {
   constructor(method: string) {
@@ -7,6 +7,14 @@ export class SlackRateLimitError extends Error {
   }
 }
 
+function resolveEnvVar(value: string): string {
+  if (value.startsWith("$")) {
+    const name = value.slice(1);
+    return process.env[name] ?? value;
+  }
+  return value;
+}
+
 // =============================================================================
 // Slack API types
 // =============================================================================
@@ -75,12 +83,12 @@ export interface ResolvedMessage {
 // =============================================================================
 
 export class SlackReader {
-  private token: string;
+  private auth: SlackAuth;
   private userCache: Map<string, string> = new Map();   // userId → displayName
   private channelCache: Map<string, string> = new Map(); // channelId → name
 
-  constructor(token: string) {
-    this.token = token;
+  constructor(auth: SlackAuth) {
+    this.auth = auth;
   }
 
   // ---------------------------------------------------------------------------
@@ -92,9 +100,14 @@ export class SlackReader {
     for (const [k, v] of Object.entries(params)) {
       url.searchParams.set(k, String(v));
     }
-    const resp = await fetch(url.toString(), {
-      headers: { Authorization: `Bearer ${this.token}` },
-    });
+    const headers: Record<string, string> = {};
+    if (this.auth.type === "browser") {
+      headers["Authorization"] = `Bearer ${resolveEnvVar(this.auth.xoxc)}`;
+      headers["Cookie"] = `d=${resolveEnvVar(this.auth.xoxd)}`;
+    } else {
+      headers["Authorization"] = `Bearer ${this.auth.token}`;
+    }
+    const resp = await fetch(url.toString(), { headers });
     if (resp.status === 429) throw new SlackRateLimitError(method);
     if (!resp.ok) throw new Error(`Slack API ${method} failed: ${resp.status}`);
     const data = await resp.json() as Record<string, unknown>;
@@ -123,7 +136,7 @@ export class SlackReader {
     return allChannels;
   }
 
-  classifyChannel(ch: SlackChannel, settings: SlackSettings): ChannelTier {
+  classifyChannel(ch: SlackChannel, settings: SlackWorkspaceConfig): ChannelTier {
     const override = settings.channel_overrides?.[ch.id];
     if (override) return override === "skip" ? "skip" : override;
     if (ch.is_im || ch.is_mpim) return "dm";
@@ -133,7 +146,7 @@ export class SlackReader {
     return "public";
   }
 
-  backfillDaysForTier(tier: ChannelTier, settings: SlackSettings): number {
+  backfillDaysForTier(tier: ChannelTier, settings: SlackWorkspaceConfig): number {
     const defaults = { dm: 90, private: 90, public: 30 };
     if (tier === "dm" || tier === "private") return settings.backfill_days?.dm ?? defaults[tier];
     if (tier === "public") return settings.backfill_days?.public ?? defaults.public;
@@ -387,7 +400,7 @@ export class SlackReader {
   selectCandidateChannel(
     channels: SlackChannel[],
     channelStates: Record<string, SlackChannelState>,
-    settings: SlackSettings,
+    settings: SlackWorkspaceConfig,
     now: string,
   ): { channel: SlackChannel; state: SlackChannelState; tier: ChannelTier } | null {
     const nowMs = new Date(now).getTime();

package/src/integrations/slack/types.ts

@@ -1,11 +1,25 @@
-export interface SlackAuth {
-  type: "pkce" | "xoxp";
-  token: string;
-  refresh_token?: string;
-  workspace_id?: string;
+export type ChannelTier = "dm" | "private" | "public" | "broadcast" | "skip";
+
+// OAuth flow (PKCE) — produces a real xoxp token with auto-refresh
+export interface SlackAuthOAuth {
+  type: "oauth";
+  token: string;           // xoxp-... user token
+  refresh_token?: string;  // xoxe-xoxp-... rotating refresh token
+  workspace_name?: string;
+}
+
+// Browser session tokens — extracted from Slack desktop app or DevTools.
+// xoxc and xoxd may be literal token strings or env var references (e.g. $RNP_SLACK_XOXC_TOKEN).
+// Env vars are resolved at call time so rotating them in the shell updates Ei automatically.
+export interface SlackAuthBrowser {
+  type: "browser";
+  xoxc: string;
+  xoxd: string;
   workspace_name?: string;
 }
 
+export type SlackAuth = SlackAuthOAuth | SlackAuthBrowser;
+
 export interface SlackChannelState {
   extraction_point?: string;         // ISO — how far we've advanced in the timeline (spine cursor)
   last_run?: string;                 // ISO — when we last checked for updates (necro reply detection)
@@ -13,18 +27,22 @@ export interface SlackChannelState {
   threads?: Record<string, string>;  // threadTs → latest reply ts seen (reply cursor per thread)
 }
 
-export interface SlackSettings {
+export interface SlackWorkspaceConfig {
+  auth: SlackAuth;
   integration?: boolean;
-  polling_interval_ms?: number;
   extraction_model?: string;
   last_sync?: string;
-  auth?: SlackAuth;
   backfill_days?: {
     dm: number;
     private: number;
     public: number;
   };
   broadcast_threshold?: number;
-  channel_overrides?: Record<string, "dm" | "private" | "public" | "skip">;
+  channel_overrides?: Record<string, ChannelTier>;
   channels?: Record<string, SlackChannelState>;
 }
+
+export interface SlackSettings {
+  polling_interval_ms?: number;
+  workspaces?: Record<string, SlackWorkspaceConfig>;  // keyed by workspace_id (e.g. "T024GE9EL")
+}

package/src/prompts/message-utils.ts

@@ -1,7 +1,7 @@
 import type { Message } from "../core/types.js";
 import { getMessageContent } from "../core/handlers/utils.js";
 
-const MESSAGE_PLACEHOLDER_REGEX = /\[mid:([a-zA-Z0-9_:-]+):([^:\]]+)\]/g;
+const MESSAGE_PLACEHOLDER_REGEX = /\[mid:(.+):([^:\]]+)\]/g;
 
 export function getMessageDisplayText(message: Message): string | null {
   const parts: string[] = [];

package/tui/src/commands/slack-auth.ts

@@ -66,19 +66,25 @@ export async function runSlackAuth(ctx: CommandContext): Promise<void> {
     clearSlackTokenCache();
 
     const team = tokens._raw.team as Record<string, string> | undefined;
-    const workspaceId = team?.id;
+    const workspaceId = team?.id ?? "unknown";
     const workspaceName = team?.name;
 
     const human = await ctx.ei.getHuman();
+    const existingWorkspace = human.settings?.slack?.workspaces?.[workspaceId] ?? {};
     await ctx.ei.updateSettings({
       slack: {
         ...human.settings?.slack,
-        auth: {
-          type: "pkce",
-          token: tokens.access_token,
-          refresh_token: tokens.refresh_token,
-          workspace_id: workspaceId,
-          workspace_name: workspaceName,
+        workspaces: {
+          ...human.settings?.slack?.workspaces,
+          [workspaceId]: {
+            ...existingWorkspace,
+            auth: {
+              type: "oauth",
+              token: tokens.access_token,
+              refresh_token: tokens.refresh_token,
+              workspace_name: workspaceName,
+            },
+          },
         },
       },
     });

package/tui/src/util/yaml-settings.ts

@@ -7,7 +7,7 @@ import type {
 } from "../../../src/core/types.js";
 import type { ClaudeCodeSettings } from "../../../src/integrations/claude-code/types.js";
 import type { CursorSettings } from "../../../src/integrations/cursor/types.js";
-import type { SlackSettings } from "../../../src/integrations/slack/types.js";
+import type { SlackSettings, SlackAuth } from "../../../src/integrations/slack/types.js";
 import { modelGuidToDisplay, displayToModelGuid } from "./yaml-shared.js";
 import { parseDuration, formatDuration } from "./duration.js";
 
@@ -48,10 +48,20 @@ interface EditableSettingsData {
     extraction_point?: string | null;
   };
   slack?: {
-    integration?: boolean | null;
     polling_interval_ms?: string | null;
-    last_sync?: string | null;
-    extraction_model?: string | null;
+    workspaces?: Record<string, {
+      auth?: {
+        type?: string | null;
+        token?: string | null;
+        refresh_token?: string | null;
+        xoxc?: string | null;
+        xoxd?: string | null;
+        workspace_name?: string | null;
+      } | null;
+      integration?: boolean | null;
+      extraction_model?: string | null;
+      last_sync?: string | null;
+    } | null>;
   };
   backup?: {
     enabled?: boolean | null;
@@ -103,10 +113,18 @@ export function settingsToYAML(settings: HumanSettings | undefined, accounts: Pr
       extraction_point: settings?.cursor?.extraction_point ?? null,
     },
     slack: {
-      integration: settings?.slack?.integration ?? false,
       polling_interval_ms: formatDuration(settings?.slack?.polling_interval_ms ?? 60000),
-      last_sync: settings?.slack?.last_sync ?? null,
-      extraction_model: guidToDisplay(settings?.slack?.extraction_model) ?? 'default',
+      workspaces: Object.fromEntries(
+        Object.entries(settings?.slack?.workspaces ?? {}).map(([wsId, ws]) => [
+          wsId,
+          {
+            auth: ws.auth,
+            integration: ws.integration ?? false,
+            extraction_model: guidToDisplay(ws.extraction_model) ?? 'default',
+            last_sync: ws.last_sync ?? null,
+          },
+        ])
+      ),
     },
     backup: {
       enabled: settings?.backup?.enabled ?? false,
@@ -188,12 +206,22 @@ export function settingsFromYAML(yamlContent: string, original: HumanSettings |
 
   let slack: SlackSettings | undefined;
   if (data.slack) {
+    const parsedWorkspaces: SlackSettings["workspaces"] = {};
+    for (const [wsId, wsData] of Object.entries(data.slack.workspaces ?? {})) {
+      if (!wsData) continue;
+      const originalWs = original?.slack?.workspaces?.[wsId] ?? {};
+      parsedWorkspaces[wsId] = {
+        ...originalWs,
+        auth: (wsData.auth ?? originalWs.auth) as SlackAuth,
+        integration: nullToUndefined(wsData.integration),
+        extraction_model: displayToGuid(wsData.extraction_model),
+        last_sync: originalWs.last_sync,
+      };
+    }
     slack = {
       ...original?.slack,
-      integration: nullToUndefined(data.slack.integration),
       polling_interval_ms: parseMsDuration(data.slack.polling_interval_ms, 60000),
-      last_sync: original?.slack?.last_sync,
-      extraction_model: displayToGuid(data.slack.extraction_model),
+      workspaces: Object.keys(parsedWorkspaces).length > 0 ? parsedWorkspaces : original?.slack?.workspaces,
     };
   }