ei-tui 1.6.0 → 1.6.2

package/src/core/orchestrators/ceremony.ts

@@ -1,4 +1,4 @@
-import { LLMRequestType, LLMPriority, LLMNextStep, RoomMode, ContextStatus, type CeremonyConfig, type PersonaTopic, type Topic } from "../types.js";
+import { LLMRequestType, LLMPriority, LLMNextStep, RoomMode, ContextStatus, type CeremonyConfig, type PersonaTopic, type Topic, type Message } from "../types.js";
 import type { StateManager } from "../state-manager.js";
 import { normalizeRoomMessages } from "../handlers/utils.js";
 import { applyDecayToValue } from "../utils/index.js";
@@ -168,9 +168,9 @@ function queueExposurePhase(personaId: string, state: StateManager, options?: Ex
  * If any ceremony_progress items remain in the queue, does nothing — more work pending.
  * Phase 1: Dedup → Phase 2: Expose → Phase 3: EventSummary → Decay → Phase 4: Person Rewrite → Topic Rewrite (fire-and-forget)
  */
-export function handleCeremonyProgress(state: StateManager, lastPhase: number): void {
+export function handleCeremonyProgress(state: StateManager, lastPhase: number): { wroteEiWarning: boolean } {
   if (state.queue_hasPendingCeremonies()) {
-    return; // Still processing ceremony items
+    return { wroteEiWarning: false }; // Still processing ceremony items
   }
   
   if (lastPhase === 1) {
@@ -232,13 +232,13 @@ export function handleCeremonyProgress(state: StateManager, lastPhase: number):
         console.log(`[ceremony:expose] Queued room persona topic rating: ${personaForRoom.display_name} in "${room.display_name}" (${unprocessedRaw.length} messages)`);
       }
     }
-    return;
+    return { wroteEiWarning: false };
   }
 
   if (lastPhase === 4) {
     console.log("[ceremony:progress] Person Rewrite complete, starting Topic Rewrite");
     queueTopicRewritePhase(state);
-    return;
+    return { wroteEiWarning: false };
   }
 
   if (lastPhase === 2) {
@@ -251,7 +251,7 @@ export function handleCeremonyProgress(state: StateManager, lastPhase: number):
       console.log("[ceremony:progress] No event summary work, advancing to Decay");
       handleCeremonyProgress(state, 3);
     }
-    return;
+    return { wroteEiWarning: false };
   }
   
   // Phase 3 (EventSummary) complete → advance to Decay/Prune then Person Rewrite (phase 4)
@@ -285,9 +285,10 @@ export function handleCeremonyProgress(state: StateManager, lastPhase: number):
   }
 
   // Reflection phase: fire-and-forget critic calls for persona person records above threshold
-  queueReflectionPhase(state);
+  const wroteEiWarning = queueReflectionPhase(state);
 
   console.log("[ceremony:progress] Ceremony Decay complete");
+  return { wroteEiWarning };
 }
 
 // =============================================================================
@@ -446,7 +447,8 @@ export function runHumanCeremony(state: StateManager): void {
 // REWRITE PHASE (fire-and-forget — queues Low-priority Phase 1 scans)
 // =============================================================================
 
-const REWRITE_DESCRIPTION_THRESHOLD = 750;
+const PERSON_REWRITE_DESCRIPTION_THRESHOLD = 1000;
+const TOPIC_REWRITE_DESCRIPTION_THRESHOLD = 750;
 
 /**
  * Forces an unconditional, threshold-bypassing Person scan on Apply/Dismiss.
@@ -473,7 +475,7 @@ export function queueReflectionDrain(personaId: string, state: StateManager): vo
     messages_analyze: unextractedPeople,
     extraction_flag: "p",
   };
-  queuePersonScan(context, state);
+  queuePersonScan(context, state, { reflection_progress: 1 });
   console.log(`[reflection:drain] Queued Person scan for ${persona.display_name} (${unextractedPeople.length} messages) — clears on completion`);
 }
 
@@ -494,7 +496,7 @@ export function queuePersonRewritePhase(state: StateManager, options?: { ceremon
       i => i.type.toLowerCase() === 'ei persona'
     );
     return !isPersonaLinked
-      && (person.description?.length ?? 0) > REWRITE_DESCRIPTION_THRESHOLD;
+      && (person.description?.length ?? 0) > PERSON_REWRITE_DESCRIPTION_THRESHOLD;
   });
 
   const alreadyChecked = allCandidates.filter(p => {
@@ -520,7 +522,7 @@ export function queuePersonRewritePhase(state: StateManager, options?: { ceremon
     return;
   }
 
-  console.log(`[ceremony:rewrite] Found ${personsToScan.length} person(s) above ${REWRITE_DESCRIPTION_THRESHOLD} chars — queueing person rewrite scans`);
+  console.log(`[ceremony:rewrite] Found ${personsToScan.length} person(s) above ${PERSON_REWRITE_DESCRIPTION_THRESHOLD} chars — queueing person rewrite scans`);
 
   for (const person of personsToScan) {
     const prompt = buildPersonRewriteScanPrompt({ item: person, itemType: "person" });
@@ -552,7 +554,7 @@ export function queueTopicRewritePhase(state: StateManager): void {
 
   const human = state.getHuman();
   const allCandidateTopics = human.topics.filter(topic =>
-    (topic.description?.length ?? 0) > REWRITE_DESCRIPTION_THRESHOLD
+    (topic.description?.length ?? 0) > TOPIC_REWRITE_DESCRIPTION_THRESHOLD
   );
 
   const alreadyCheckedTopics = allCandidateTopics.filter(t => {
@@ -578,7 +580,7 @@ export function queueTopicRewritePhase(state: StateManager): void {
     return;
   }
 
-  console.log(`[ceremony:rewrite] Found ${topicsToScan.length} topic(s) above ${REWRITE_DESCRIPTION_THRESHOLD} chars — queueing topic rewrite scans`);
+  console.log(`[ceremony:rewrite] Found ${topicsToScan.length} topic(s) above ${TOPIC_REWRITE_DESCRIPTION_THRESHOLD} chars — queueing topic rewrite scans`);
 
   for (const topic of topicsToScan) {
     const prompt = buildTopicRewriteScanPrompt({ item: topic, itemType: "topic" });
@@ -615,16 +617,43 @@ function queueEventSummaryForAll(state: StateManager, options?: ExtractionOption
   console.log(`[ceremony:event] Queued event summary scans for ${activePersonas.length} personas (${totalQueued} total chunks)`);
 }
 
-function queueReflectionPhase(state: StateManager): void {
+function queueReflectionPhase(state: StateManager): boolean {
   const personas = state.persona_getAll().filter(p =>
     !p.is_paused && !p.is_archived && !p.is_static
   );
 
+  const human = state.getHuman();
   let queued = 0;
+  let wroteEiWarning = false;
+
   for (const persona of personas) {
-    const personRecord = state.human_person_getByIdentifier("Ei Persona", persona.id);
-    if (!personRecord || (personRecord.description?.length ?? 0) <= PERSON_LOG_REFLECTION_THRESHOLD) continue;
+    const linkedRecords = human.people.filter(p =>
+      p.identifiers?.some(i => i.type.toLowerCase() === 'ei persona' && i.value === persona.id)
+    );
+
+    if (linkedRecords.length === 0) continue;
+
+    const overThreshold = linkedRecords.filter(p => (p.description?.length ?? 0) > PERSON_LOG_REFLECTION_THRESHOLD);
+    if (overThreshold.length === 0) continue;
+
+    if (linkedRecords.length > 1) {
+      const names = linkedRecords.map(p => `"${p.name}"`).join(" and ");
+      console.log(`[ceremony:reflection] ${persona.display_name} is linked to multiple person records (${names}) — skipping reflection, writing Ei warning`);
+
+      const warning: Message = {
+        id: crypto.randomUUID(),
+        role: "system",
+        content: `During today's ceremony, I noticed that **${persona.display_name}** is connected to multiple person records: ${names}. This might be intentional — if you created a composite persona — but if not, you may want to check the identifiers on those records. Reflection for ${persona.display_name} has been paused until this is resolved.`,
+        timestamp: new Date().toISOString(),
+        read: false,
+        context_status: ContextStatus.Always,
+      };
+      state.messages_append("ei", warning);
+      wroteEiWarning = true;
+      continue;
+    }
 
+    const personRecord = linkedRecords[0];
     const prompt = buildReflectionCriticPrompt({
       persona_identity: {
         name: persona.display_name,
@@ -650,7 +679,9 @@ function queueReflectionPhase(state: StateManager): void {
     console.log(`[ceremony:reflection] Queued critic for ${persona.display_name} (person log: ${personRecord.description?.length} chars)`);
   }
 
-  if (queued === 0) {
+  if (queued === 0 && !wroteEiWarning) {
     console.log("[ceremony:reflection] No persona person records above threshold — skipping");
   }
+
+  return wroteEiWarning;
 }

package/src/core/processor.ts

@@ -36,7 +36,8 @@ import { handlers } from "./handlers/index.js";
 import { normalizeRoomMessages, getMessageContent } from "./handlers/utils.js";
 import { sanitizeEiPersonaIdentifiers } from "./utils/identifier-utils.js";
 import { ContextStatus as ContextStatusEnum, RoomMode } from "./types.js";
-import { registerFindMemoryExecutor, registerFetchMemoryExecutor, registerFetchMessageExecutor, registerFileReadExecutor, SYSTEM_TOOLS } from "./tools/index.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";
 import { createFetchMemoryExecutor } from "./tools/builtin/fetch-memory.js";
 import { createFetchMessageExecutor } from "./tools/builtin/fetch-message.js";
@@ -147,6 +148,7 @@ 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;
 
@@ -169,6 +171,8 @@ export class Processor {
   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;
@@ -252,6 +256,10 @@ export class Processor {
     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)));
+    registerPersonaNoteExecutors(
+      createAddNoteExecutor(this.stateManager.persona_getById.bind(this.stateManager), this.stateManager.persona_update.bind(this.stateManager)),
+      createClearNoteExecutor(this.stateManager.persona_getById.bind(this.stateManager), this.stateManager.persona_update.bind(this.stateManager))
+    );
     if (this.isTUI) {
       await registerFileReadExecutor();
       const retrievalPath = "../cli/retrieval.js";
@@ -1195,6 +1203,14 @@ export class Processor {
       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",
@@ -1272,6 +1288,14 @@ export class Processor {
       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;
@@ -1414,7 +1438,7 @@ const toolNextSteps = new Set([
                 t.name === "find_memory" || t.name === "fetch_memory" || t.name === "fetch_message"
               );
             } else if (toolNextSteps.has(request.next_step) && toolPersonaId) {
-              tools = [...SYSTEM_TOOLS, ...this.stateManager.tools_getForPersona(toolPersonaId, this.isTUI)];
+              tools = [...SYSTEM_TOOLS, ...buildPersonaNoteTools(toolPersonaId), ...this.stateManager.tools_getForPersona(toolPersonaId, this.isTUI)];
             }
 
             // Auto-inject each handler's dedicated submit tool — infrastructure, not user-visible.
@@ -1517,6 +1541,14 @@ const toolNextSteps = new Set([
       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 &&
@@ -1774,6 +1806,60 @@ const toolNextSteps = new Set([
       });
   }
 
+  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;
 
@@ -2103,7 +2189,10 @@ const toolNextSteps = new Set([
       }
 
       if (typeof response.request.data.ceremony_progress === "number") {
-        handleCeremonyProgress(this.stateManager, response.request.data.ceremony_progress);
+        const ceremonyResult = handleCeremonyProgress(this.stateManager, response.request.data.ceremony_progress);
+        if (ceremonyResult.wroteEiWarning) {
+          this.interface.onMessageAdded?.("ei");
+        }
       }
 
       if (response.request.next_step === LLMNextStep.HandleDocumentSegmentation) {

package/src/core/prompt-context-builder.ts

@@ -302,6 +302,7 @@ export async function buildResponsePromptData(
       interested_topics: persona.topics.filter(t => t.exposure_desired - t.exposure_current > 0.2),
       include_message_timestamps: persona.include_message_timestamps,
       pending_update: persona.pending_update,
+      notes: persona.notes,
     },
     human: filteredHuman,
     visible_personas: visiblePersonas,
@@ -395,6 +396,7 @@ export async function buildRoomResponsePromptData(
       traits: respondingPersona.traits,
       topics: respondingPersona.topics,
       include_message_timestamps: respondingPersona.include_message_timestamps,
+      notes: respondingPersona.notes,
     },
     other_participants: otherParticipants,
     human: filteredHuman,

package/src/core/tools/builtin/persona-notes.ts

@@ -0,0 +1,81 @@
+import type { ToolExecutor } from "../types.js";
+import type { PersonaEntity } from "../../types.js";
+
+export const NOTES_MAX = 20;
+
+type GetPersona = (id: string) => PersonaEntity | null;
+type UpdatePersona = (id: string, updates: Partial<PersonaEntity>) => boolean;
+
+export function createAddNoteExecutor(getPersona: GetPersona, updatePersona: UpdatePersona): ToolExecutor {
+  return {
+    name: "add_note",
+
+    async execute(args: Record<string, unknown>, config?: Record<string, string>): Promise<string> {
+      const personaId = config?.persona_id ?? "";
+      const text = typeof args.text === "string" ? args.text.trim() : "";
+      console.log(`[add_note] persona="${personaId}" text="${text.slice(0, 60)}"`);
+
+      if (!personaId) {
+        return JSON.stringify({ error: "Tool misconfigured: missing persona_id" });
+      }
+      if (!text) {
+        return JSON.stringify({ error: "Missing required argument: text" });
+      }
+
+      const persona = getPersona(personaId);
+      if (!persona) {
+        return JSON.stringify({ error: "Persona not found" });
+      }
+
+      const notes = [...(persona.notes ?? [])];
+
+      if (notes.length >= NOTES_MAX) {
+        notes.shift();
+      }
+
+      notes.push(text);
+      updatePersona(personaId, { notes });
+
+      const index = notes.length;
+      console.log(`[add_note] added note at position ${index}/${NOTES_MAX}`);
+      return JSON.stringify({ added: true, index, total: notes.length });
+    },
+  };
+}
+
+export function createClearNoteExecutor(getPersona: GetPersona, updatePersona: UpdatePersona): ToolExecutor {
+  return {
+    name: "clear_note",
+
+    async execute(args: Record<string, unknown>, config?: Record<string, string>): Promise<string> {
+      const personaId = config?.persona_id ?? "";
+      const index = typeof args.index === "number" ? args.index : NaN;
+      console.log(`[clear_note] persona="${personaId}" index=${index}`);
+
+      if (!personaId) {
+        return JSON.stringify({ error: "Tool misconfigured: missing persona_id" });
+      }
+      if (!Number.isInteger(index) || index < 1) {
+        return JSON.stringify({ error: "index must be an integer >= 1" });
+      }
+
+      const persona = getPersona(personaId);
+      if (!persona) {
+        return JSON.stringify({ error: "Persona not found" });
+      }
+
+      const notes = [...(persona.notes ?? [])];
+      const zeroIdx = index - 1;
+
+      if (zeroIdx >= notes.length) {
+        return JSON.stringify({ error: `No note at index ${index} (total: ${notes.length})` });
+      }
+
+      notes.splice(zeroIdx, 1);
+      updatePersona(personaId, { notes });
+
+      console.log(`[clear_note] removed note at index ${index}, remaining=${notes.length}`);
+      return JSON.stringify({ cleared: true, index, remaining: notes.length });
+    },
+  };
+}

package/src/core/tools/index.ts

@@ -12,6 +12,7 @@ import { tavilyWebSearchExecutor, tavilyNewsSearchExecutor } from "./builtin/web
 import { currentlyPlayingExecutor } from "./builtin/currently-playing.js";
 import { likedSongsExecutor } from "./builtin/spotify-liked-songs.js";
 import { webFetchExecutor } from "./builtin/web-fetch.js";
+import { NOTES_MAX } from "./builtin/persona-notes.js";
 // file-read and list-directory are Node-only — imported lazily via registerFileReadExecutor() to avoid
 // file-read and list-directory are Node-only — imported lazily via registerFileReadExecutor() to avoid
 
@@ -128,6 +129,61 @@ export function registerFetchMessageExecutor(executor: ToolExecutor): void {
   executorRegistry.set(executor.name, executor);
 }
 
+export function registerPersonaNoteExecutors(executor1: ToolExecutor, executor2: ToolExecutor): void {
+  executorRegistry.set(executor1.name, executor1);
+  executorRegistry.set(executor2.name, executor2);
+}
+
+/**
+ * Build per-request ToolDefinition objects for the persona notes tools, injecting the
+ * current personaId via config so the shared executor knows which persona to update.
+ */
+export function buildPersonaNoteTools(personaId: string): ToolDefinition[] {
+  const now = new Date(0).toISOString();
+  return [
+    {
+      id: `builtin-add-note-${personaId}`,
+      provider_id: "ei",
+      name: "add_note",
+      display_name: "Add Note",
+      description: `In Ei, your system prompt can change from one turn to the next — Ei is constantly trying to provide you relevant, up-to-date information about the user and the world. If you see something in your system prompt that you don't immediately want to bring up, but want to remember, use this tool to record it for later. Additionally, if you need to remember something but cannot or should not say it directly in conversation, you can use this tool to make a note as well. Notes appear in your system prompt as a numbered list so you always see them. Limit: ${NOTES_MAX} notes (oldest evicted when full).`,
+      input_schema: {
+        type: "object",
+        properties: {
+          text: { type: "string", description: "The note to remember. Keep it concise." },
+        },
+        required: ["text"],
+      },
+      config: { persona_id: personaId },
+      runtime: "any",
+      builtin: true,
+      enabled: true,
+      created_at: now,
+      max_calls_per_interaction: 5,
+    },
+    {
+      id: `builtin-clear-note-${personaId}`,
+      provider_id: "ei",
+      name: "clear_note",
+      display_name: "Clear Note",
+      description: "Remove a note from your scratchpad by its 1-based index (matching the numbered list in your system prompt). Use when you no longer need to track something — e.g., after you've addressed it in conversation.",
+      input_schema: {
+        type: "object",
+        properties: {
+          index: { type: "number", description: "1-based index of the note to remove" },
+        },
+        required: ["index"],
+      },
+      config: { persona_id: personaId },
+      runtime: "any",
+      builtin: true,
+      enabled: true,
+      created_at: now,
+      max_calls_per_interaction: 5,
+    },
+  ];
+}
+
 /**
  * Register the file_read, list_directory, directory_tree, search_files, grep, and get_file_info
  * executors — called by Processor on TUI/Node only.

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

@@ -15,7 +15,7 @@ export interface DataItemBase {
   learned_by?: string;           // Persona ID that originally learned this item (stable UUID)
   last_changed_by?: string;      // Persona ID that most recently updated this item (stable UUID)
   interested_personas?: string[]; // Persona IDs that have extracted/touched this item (accumulated)
-  sources?: string[];            // Namespaced source identifiers — where items were learned from. Format: "provider:id" (e.g., "opencode:ses_abc123", "cursor:composerId"). Grow-only union.
+  sources?: string[];            // Namespaced source identifiers — where items were learned from. Format: "provider:id" (e.g., "opencode:ses_abc123", "cursor:composerId", "codex:threadId"). Grow-only union.
   persona_groups?: string[];
   embedding?: number[];
   rewrite_length_floor?: number; // Set after every rewrite scan: ceil(description.length * 1.1). Item is skipped by ceremony until description grows past this floor. Preserved across extraction upserts — only cleared when description exceeds it.

package/src/core/types/entities.ts

@@ -130,6 +130,7 @@ export interface HumanSettings {
   backup?: BackupConfig;
   claudeCode?: import("../../integrations/claude-code/types.js").ClaudeCodeSettings;
   cursor?: import("../../integrations/cursor/types.js").CursorSettings;
+  codex?: import("../../integrations/codex/types.js").CodexSettings;
   document?: DocumentSettings;
   active_theme?: string;
   custom_themes?: ThemeDefinition[];
@@ -185,6 +186,7 @@ export interface PersonaEntity {
   avatar_emoji?: string;            // Single emoji character used as avatar in place of initials.
   avatar_image?: string;            // Base64-encoded 64×64 image used as avatar (takes priority over avatar_emoji).
   preferred_theme?: string;         // Theme ID (built-in name or ThemeDefinition.id). Applied to chat panel when this persona is active.
+  notes?: string[];                 // Private scratchpad — up to 20 short-term notes visible in the system prompt. Oldest evicted when full.
 }
 
 export interface PersonaCreationInput {

package/src/core/types/llm.ts

@@ -25,7 +25,7 @@ export interface Message {
   _synthesis?: boolean;         // True if message was created by multi-message synthesis
   speaker_name?: string;       // Display name of actual speaker; set on room messages for clean hydration
 
-  external?: boolean;          // Set by integration importers (OpenCode, Cursor, Claude Code); invisible to LLM context
+  external?: boolean;          // Set by integration importers (OpenCode, Cursor, Claude Code, Codex); invisible to LLM context
 
 }
 

package/src/core/utils/message-id.ts

@@ -4,6 +4,7 @@
  *   opencode:${machine}:${session}:${nativeId}
  *   claudecode:${machine}:${session}:${nativeId}
  *   cursor:${machine}:${session}:${nativeId}
+ *   codex:${machine}:${session}:${nativeId}
  *   import:document:${slug}:${uuid}
  *   slack:${workspace}:${channel}:${ts}
  */
@@ -13,6 +14,7 @@ export type MessageIdIntegration =
   | "opencode"
   | "claudecode"
   | "cursor"
+  | "codex"
   | "import"
   | "slack"
   | "unknown"
@@ -67,6 +69,16 @@ export function parseMessageId(id: string): ParsedMessageId {
     }
   }
 
+  if (parts[0] === "codex" && parts.length >= 4) {
+    return {
+      integration: "codex",
+      machine: parts[1],
+      session: parts[2],
+      nativeId: parts.slice(3).join(":"),
+      raw: id,
+    }
+  }
+
   if (parts[0] === "import" && parts[1] === "document" && parts.length >= 4) {
     return {
       integration: "import",
@@ -109,6 +121,10 @@ export function qualifyCursorMessage(machine: string, sessionId: string, nativeI
   return `cursor:${machine}:${sessionId}:${nativeId}`
 }
 
+export function qualifyCodexMessage(machine: string, sessionId: string, nativeId: string): string {
+  return `codex:${machine}:${sessionId}:${nativeId}`
+}
+
 export function qualifyDocumentMessage(slug: string, uuid: string): string {
   return `import:document:${slug}:${uuid}`
 }