ei-tui 0.9.3 → 1.0.0

package/README.md

@@ -83,7 +83,7 @@ Ei can operate with three types of input, and three types of output.
                        ^
                     Sessions
                        |
-                   [OpenCode]
+          [OpenCode / Claude Code / Cursor]
 ```
 
 ```
@@ -169,6 +169,22 @@ All sessions map to a single "Cursor" persona.
 
 Sessions are processed oldest-first, one per queue cycle, so Ei won't overwhelm your LLM provider on first run. See [TUI Readme](tui/README.md)
 
+## Document Import
+
+Got notes, journals, markdown files? You can feed them directly to Ei.
+
+**Web**: Open **☰ menu** → **My Data** → **Documents** tab. Drop a `.txt`, `.md`, or `.markdown` file and Ei gets to work.
+
+**TUI**:
+```bash
+/import ~/notes/my-journal.md
+/import /path/to/report.pdf
+```
+
+Ei splits the document into segments, runs them through the extraction pipeline, and pulls out facts, topics, people, and quotes — exactly like it does with your conversations. The extracted knowledge is attributed to a reserved persona called **Emmett** so it doesn't pollute your chat history.
+
+Both surfaces show you which documents have been imported and let you remove their extracted knowledge (web: Delete button in the Documents tab; TUI: `/unsource <source_tag>`).
+
 ## Built-in Tool Integrations
 
 Personas can use tools. Not just read-from-memory tools — *actual* tools. Web search. Your music. Your filesystem. Here's what ships with Ei out of the box:
@@ -184,6 +200,7 @@ Personas can use tools. Not just read-from-memory tools — *actual* tools. Web
 | `search_files` | Find files by name pattern *(TUI only)* |
 | `grep` | Search file contents by regex *(TUI only)* |
 | `get_file_info` | File/directory metadata *(TUI only)* |
+| `web_fetch` | Fetch a URL and return its text content *(TUI only — blocked by CORS in browsers)* |
 
 The filesystem tools make Ei a legitimate coding assistant in the TUI. Ask a persona to review a file, understand a project structure, or track down where something is defined — it can actually look.
 
@@ -264,13 +281,15 @@ Tag a version to publish automatically:
 
 ```bash
 # bump version in package.json
-git commit -am "chore: bump to v0.1.4"
-git tag v0.1.4
+git commit -am "chore: bump to v1.0.0"
+git tag v1.0.0
 git push && git push --tags
 ```
 
 GitHub Actions picks up the tag and publishes to npm with provenance via OIDC. No stored secrets.
 
+> **Note**: Run the pre-flight checklist in `AGENTS.md` (or use the `release` skill in OpenCode) before tagging. The v0.1.9 incident is a cautionary tale.
+
 ## Project Structure
 
 See `AGENTS.md` for detailed architecture and contribution guidelines.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ei-tui",
-  "version": "0.9.3",
+  "version": "1.0.0",
   "author": "Flare576",
   "repository": {
     "type": "git",
@@ -57,13 +57,20 @@
     "test:evals:topic-scan": "vite-node tests/evals/topic-scan.eval.ts",
     "test:evals:topic-match": "vite-node tests/evals/topic-match.eval.ts",
     "test:evals:topic-update": "vite-node tests/evals/topic-update.eval.ts",
+    "test:evals:topic-technical": "vite-node tests/evals/topic-technical.eval.ts",
+    "test:evals:rewrite-scan": "vite-node tests/evals/rewrite-scan.eval.ts",
+    "test:evals:rewrite-rewrite": "vite-node tests/evals/rewrite-rewrite.eval.ts",
+    "test:evals:rewrite-real-data": "vite-node tests/evals/rewrite-real-data.eval.ts",
     "test:evals:topic-validate": "vite-node tests/evals/topic-validate.eval.ts",
     "test:evals:person-scan": "vite-node tests/evals/person-scan.eval.ts",
     "test:evals:person-update": "vite-node tests/evals/person-update.eval.ts",
     "test:evals:persona-trait": "vite-node tests/evals/persona-trait-extraction.eval.ts",
     "test:evals:dedup": "vite-node tests/evals/dedup-tool-calls.eval.ts",
     "test:evals:response-read-memory": "vite-node tests/evals/response-read-memory.eval.ts",
+    "test:evals:response-pending-update": "vite-node tests/evals/response-pending-update.eval.ts",
+    "test:evals:heartbeat-pending-update": "vite-node tests/evals/heartbeat-pending-update.eval.ts",
     "test:evals:real-data": "vite-node tests/evals/real-data-example.eval.ts",
+    "test:evals:persona-data-check": "vite-node tests/evals/persona-data-check.eval.ts",
     "test:all": "npm run test && npm run test:e2e && npm run test:e2e:tui",
     "typecheck": "tsc --noEmit",
     "web": "cd web && npm run dev",

package/src/README.md

@@ -57,39 +57,23 @@ Each Topic will have an "exposure" rating similar to those on Human Data points.
 
 # Ceremony Intent
 
-Every 24 hours, we want to freshen up the system. We do this in 4 parts: Exposure, Decay, Expire, Explore
+Every 24 hours, the system runs a ceremony to keep knowledge fresh and healthy. Phases run sequentially via `ceremony_progress`:
 
-## Exposure
+**Phase 1 → Dedup**: User-triggered only (not automated). Merges confirmed duplicate records.
 
-I also frequently refer to this as "Extract," but this is the first step where we determine what the human and that Persona talked about that day. It serves two purposes:
+**Phase 2 → Expose**: Human extraction catch-up (facts, topics, people) + persona topic rating for any messages that didn't hit the per-send threshold during the day.
 
-### Detail Extraction
+**Phase 3 → EventSummary**: Summarizes significant events from recent conversations.
 
-Since we also pull out details during normal discourse (see above), this is the less-important step at this point, but still vital for catching up with the last few messages, or Personas that only received a few messages during the day and may not have hit the current limit for natural extraction.
+**Decay** (synchronous after Phase 3): Applies exposure decay to persona topics + prunes old messages. Human ceremony (decay for human topics/people) runs here too.
 
-### Exposure Adjustment
+**Phase 4 → Person Rewrite**: Scans bloated Person records (>750 chars) and extracts non-relationship content into Topics. Gated so Topic Rewrite can snapshot the updated Topic list afterward.
 
-Exposure is calculated by two metrics - `desired` and `current`. If an entity REALLY likes talking about a subject, their `desired` will be very high (1.0 max), ranging down to 0.0 for subjects which that entity does NOT wish to discuss. You may have guessed already, but `current` is how much they've recently talked about a topic.
+**Topic Rewrite** (fire-and-forget after Phase 4): Scans bloated Topic records (>750 chars) and splits them into focused sub-topics. Topics created by Person Rewrite are included.
 
-Adjusting the values is different for Human Topics/People than Persona Topics. The Human subjects are actually adjusted during the previous step, while extracting details.
+**Reflection** (fire-and-forget alongside Phase 4): Persona-side critic pass on person records.
 
-The Persona Topic update only happens during the Ceremony, and really this step only increases exposure IF the subject was discussed, bumping the last_updated field accordingly.
-
-## Decay
-
-After we determine if topics were discussed (increasing exposure), we adjust exposure the _other_ way. Based on some heuristics (like current level, desired level, and time-since-discussion), we decrease the current exposure levels down.
-
-## Expire
-
-This and the following step (Explore) are exclusive to Persona Topics right now. In Expire, we analyze the Person Topics to determine if any of them have
-- Lost their meaning to the Persona
-- Been ignored or dismissed by the user
-
-This is largely tracked by exposure, but expiration is dictated by an Agent.
-
-## Explore
-
-After we've removed irrelevant topics, this is the Agent's opportunity to add NEW topics that might be of interest to the Persona (and the user). Again, it's a prompt to an agent if the Persona doesn't have its full capacity of Topics.
+> **Note**: Expire and Explore phases were removed in the Persona Ceremony Simplification (2026-04-05). Persona topics now only update `exposure_current` during ceremony. See CONTRACTS.md changelog for details.
 
 # Opencode Importer
 
@@ -148,7 +132,7 @@ This is intentional. Concurrent LLM calls sound appealing until you're watching
 
 # Context Windows
 
-Personas don't send their entire message history to the LLM. By default, only messages from the last 8 hours are included (`context_window_hours`, configurable per persona). Older messages are still stored — they're just not in the prompt.
+Personas don't send their entire message history to the LLM. By default, only messages from the last 8 hours are included (`context_window_ms`, configurable per persona). Older messages are still stored — they're just not in the prompt.
 
 Message rolloff works differently: messages are kept until there are at least 200 of them _and_ any are older than 14 days. So a persona you chat with daily will roll off old messages gradually; one you chat with twice a year will keep everything.
 

package/src/core/context-utils.ts

@@ -8,12 +8,12 @@ import { ContextStatus as ContextStatusEnum } from "./types.js";
 export function filterMessagesForContext(
   messages: Message[],
   contextBoundary: string | undefined,
-  contextWindowHours: number
+  contextWindowMs: number
 ): Message[] {
   if (messages.length === 0) return [];
 
   const now = Date.now();
-  const windowStartMs = now - contextWindowHours * 60 * 60 * 1000;
+  const windowStartMs = now - contextWindowMs;
   const boundaryMs = contextBoundary ? new Date(contextBoundary).getTime() : 0;
 
   return messages.filter((msg) => {

package/src/core/handlers/document-segmentation.ts

@@ -0,0 +1,113 @@
+import { ContextStatus } from "../types.js";
+import type { LLMResponse, Message } from "../types.js";
+import type { StateManager } from "../state-manager.js";
+import {
+  queueAllScans,
+  type ExtractionContext,
+} from "../orchestrators/human-extraction.js";
+
+function parseSegmentArray(content: string): string[] | null {
+  const jsonMatch = content.match(/```json\s*([\s\S]*?)```/) ?? content.match(/```\s*([\s\S]*?)```/);
+  const jsonText = jsonMatch ? jsonMatch[1].trim() : content.trim();
+
+  const arrayMatch = jsonText.match(/\[[\s\S]*\]/);
+  if (!arrayMatch) return null;
+
+  try {
+    const parsed = JSON.parse(arrayMatch[0]);
+    if (!Array.isArray(parsed)) return null;
+    return parsed.filter((item): item is string => typeof item === "string" && item.trim().length > 0);
+  } catch {
+    return null;
+  }
+}
+
+export function handleDocumentSegmentation(response: LLMResponse, state: StateManager): void {
+  const { batchId, filename, originalContent } = response.request.data as {
+    batchId: string;
+    filename: string;
+    originalContent: string;
+  };
+
+  if (!batchId || !filename) {
+    console.error("[handleDocumentSegmentation] Missing batchId or filename in request data");
+    return;
+  }
+
+  let segments: string[];
+  if (response.content) {
+    const parsed = parseSegmentArray(response.content);
+    segments = (parsed && parsed.length > 0) ? parsed : [originalContent];
+  } else {
+    segments = [originalContent];
+  }
+
+  const emmett = state.persona_getById("emmet");
+  if (!emmett) {
+    console.warn("[handleDocumentSegmentation] Emmett persona not found — skipping segment write");
+    return;
+  }
+
+  const now = new Date().toISOString();
+  const sourceTag = `import:document:${filename}`;
+
+  for (const segment of segments) {
+    const message: Message = {
+      id: crypto.randomUUID(),
+      role: "system",
+      content: segment,
+      timestamp: now,
+      read: true,
+      context_status: ContextStatus.Always,
+      external: true,
+      source_tag: sourceTag,
+    };
+    state.messages_append("emmet", message);
+  }
+
+  console.log(`[handleDocumentSegmentation] Wrote ${segments.length} segment(s) for batch ${batchId} (${filename})`);
+}
+
+export function finishDocumentBatch(batchId: string, filename: string, state: StateManager): void {
+  const sourceTag = `import:document:${filename}`;
+
+  const emmettMessages = state.messages_get("emmet");
+  const docMessages = emmettMessages.filter(m => m.external === true && m.source_tag === sourceTag);
+
+  if (docMessages.length === 0) {
+    console.warn(`[finishDocumentBatch] No messages found for ${sourceTag} — skipping extraction`);
+  } else {
+    const extractionContext: ExtractionContext = {
+      personaId: "emmet",
+      channelDisplayName: "Document",
+      messages_context: [],
+      messages_analyze: docMessages,
+      sources: [sourceTag],
+    };
+
+    const docSettings = state.getHuman().settings?.document;
+    queueAllScans(extractionContext, state, {
+      extraction_model: docSettings?.extraction_model,
+      external_filter: "only",
+    });
+
+    console.log(`[finishDocumentBatch] Queued extraction for ${docMessages.length} message(s) from ${filename}`);
+  }
+
+  const updatedHuman = state.getHuman();
+  state.setHuman({
+    ...updatedHuman,
+    settings: {
+      ...updatedHuman.settings,
+      document: {
+        ...updatedHuman.settings?.document,
+        processed_documents: {
+          ...(updatedHuman.settings?.document?.processed_documents ?? {}),
+          [filename]: new Date().toISOString(),
+        },
+      },
+    },
+  });
+
+  console.log(`[finishDocumentBatch] Batch ${batchId} complete, ${filename} marked processed`);
+}

package/src/core/handlers/heartbeat.ts

@@ -126,13 +126,15 @@ export function handleReflectionCritic(response: LLMResponse, state: StateManage
   const personaDisplayName = response.request.data.personaDisplayName as string;
 
   const result = response.parsed as ReflectionCriticResult | undefined;
-  if (!result?.updated_identity || !result.critique) {
+  if (!result?.critique) {
     console.error(`[ReflectionCritic ${personaDisplayName}] Invalid or missing parsed result`);
     return;
   }
 
   const personRecord = state.human_person_getByIdentifier("Ei Persona", personaId);
   if (personRecord) {
+    // TODO: Remove before v1 — debug logging to inspect person log before it's cleared
+    console.log(`[ReflectionCritic ${personaDisplayName}] person_log_snapshot (${personRecord.description?.length ?? 0} chars): ${personRecord.description ?? ""}`);
     state.human_person_upsert({
       ...personRecord,
       description: "",
@@ -140,6 +142,12 @@ export function handleReflectionCritic(response: LLMResponse, state: StateManage
     console.log(`[ReflectionCritic ${personaDisplayName}] Person record description cleared — ready for fresh evidence after reflection`);
   }
 
+  // Escape hatch: critic found no meaningful drift — log critique and skip pending_update
+  if (!result.updated_identity) {
+    console.log(`[ReflectionCritic ${personaDisplayName}] No drift detected — skipping pending_update. Critique: ${result.critique}`);
+    return;
+  }
+
   const persona = state.persona_getById(personaId);
   if (!persona) {
     console.error(`[ReflectionCritic ${personaDisplayName}] Persona not found after critic`);

package/src/core/handlers/human-extraction.ts

@@ -189,7 +189,10 @@ export async function handleHumanPersonScan(response: LLMResponse, state: StateM
     return;
   }
 
-  const context = response.request.data as unknown as ExtractionContext;
+  const context = {
+    ...(response.request.data as unknown as ExtractionContext),
+    channelDisplayName: (response.request.data as Record<string, unknown>).personaDisplayName as string,
+  };
   if (!context?.personaId) return;
 
   const { messages_context, messages_analyze } = resolveMessageWindow(response, state);

package/src/core/handlers/human-matching.ts

@@ -8,7 +8,7 @@ import {
 import type { PersonIdentifier } from "../types/data-items.js";
 import type { StateManager } from "../state-manager.js";
 import type { ItemMatchResult, ExposureImpact, TopicUpdateResult, PersonUpdateResult } from "../../prompts/human/types.js";
-import { queueTopicUpdate, queuePersonUpdate, queueTopicValidate, type ExtractionContext } from "../orchestrators/index.js";
+import { queueTopicUpdate, queueTopicValidate, type ExtractionContext } from "../orchestrators/index.js";
 import { getEmbeddingService, getTopicEmbeddingText, getPersonEmbeddingText } from "../embedding-service.js";
 import { calculateExposureCurrent } from "../utils/exposure.js";
 
@@ -48,7 +48,7 @@ export function handleTopicMatch(response: LLMResponse, state: StateManager): vo
     extraction_model?: string;
   } = {
     personaId,
-    personaDisplayName,
+    channelDisplayName: personaDisplayName,
     roomId,
     messages_context,
     messages_analyze,
@@ -64,54 +64,6 @@ export function handleTopicMatch(response: LLMResponse, state: StateManager): vo
   console.log(`[handleTopicMatch] topic "${context.candidateName}": ${matched}`);
 }
 
-export function handlePersonMatch(response: LLMResponse, state: StateManager): void {
-  const result = response.parsed as ItemMatchResult | undefined;
-  if (!result) {
-    throw new Error("[handlePersonMatch] No parsed result");
-  }
-
-  const personaId = response.request.data.personaId as string;
-  const personaDisplayName = response.request.data.personaDisplayName as string;
-  const roomId = response.request.data.roomId as string | undefined;
-  const { messages_context, messages_analyze } = resolveMessageWindow(response, state);
-
-  let matched_guid = result.matched_guid;
-  let resolvedPerson: import('../types/data-items.js').Person | null = null;
-  if (matched_guid === "new") {
-    matched_guid = null;
-  } else if (matched_guid) {
-    const human = state.getHuman();
-    resolvedPerson = human.people.find(p => p.id === matched_guid) ?? null;
-    if (!resolvedPerson) {
-      console.warn(`[handlePersonMatch] matched_guid "${matched_guid}" not found in people — treating as new`);
-      matched_guid = null;
-    }
-  }
-  result.matched_guid = matched_guid;
-
-  const context: ExtractionContext & {
-    candidateName: string;
-    candidateDescription: string;
-    candidateRelationship: string;
-    extraction_model?: string;
-  } = {
-    personaId,
-    personaDisplayName,
-    roomId,
-    messages_context,
-    messages_analyze,
-    sources: response.request.data.sources as string[] | undefined,
-    candidateName: response.request.data.candidateName as string,
-    candidateDescription: response.request.data.candidateDescription as string,
-    candidateRelationship: response.request.data.candidateRelationship as string,
-    extraction_model: response.request.data.extraction_model as string | undefined,
-  };
-
-  queuePersonUpdate(result, context, state, resolvedPerson);
-  const matched = matched_guid ? `matched GUID "${matched_guid}"` : "no match (new person)";
-  console.log(`[handlePersonMatch] person "${context.candidateName}": ${matched}`);
-}
-
 export async function handleTopicUpdate(response: LLMResponse, state: StateManager): Promise<void> {
   const result = response.parsed as (TopicUpdateResult & { quotes?: Array<{ text: string; reason: string }> }) | undefined;
 
@@ -447,7 +399,7 @@ async function validateAndStoreQuotes(
   candidates: Array<{ text: string; reason: string }> | undefined,
   messages: Message[],
   dataItemId: string,
-  personaName: string,
+  channelDisplayName: string,
   personaGroup: string | null,
   state: StateManager
 ): Promise<void> {
@@ -540,8 +492,8 @@ async function validateAndStoreQuotes(
         data_item_ids: [dataItemId],
         persona_groups: [personaGroup || "General"],
         text: matchText,
-        speaker: message.role === "human" ? "human" : (message.speaker_name ?? personaName),
-        channel: personaName,
+        speaker: message.role === "human" ? "human" : (message.speaker_name ?? channelDisplayName),
+        channel: channelDisplayName,
         timestamp: message.timestamp,
         start: matchStart,
         end: matchEnd,

package/src/core/handlers/index.ts

@@ -1,14 +1,11 @@
 import { LLMNextStep } from "../types.js";
-import type { LLMResponse } from "../types.js";
-import type { StateManager } from "../state-manager.js";
 import type { ResponseHandler } from "./persona-response.js";
-import type { PersonIdentifier } from "../types/data-items.js";
 
 export type { ResponseHandler } from "./persona-response.js";
 
 import { handlePersonaResponse, handleToolContinuation, handleOneShot, handleOneShotJSON } from "./persona-response.js";
 import { handleHeartbeatCheck, handleEiHeartbeat, handleReflectionCritic } from "./heartbeat.js";
-import { handlePersonaGeneration, handlePersonaDescriptions, handlePersonaTraitExtraction } from "./persona-generation.js";
+import { handlePersonaGeneration, handlePersonaTraitExtraction } from "./persona-generation.js";
 import {
   handlePersonaTopicRating,
 } from "./persona-topics.js";
@@ -18,56 +15,11 @@ import { handleRewriteScan, handleRewriteRewrite } from "./rewrite.js";
 import { handleDedupCurate } from "./dedup.js";
 import { handleRoomResponse, handleRoomJudge } from "./rooms.js";
 import { handlePersonaPreview } from "./persona-preview.js";
-
-function handlePersonIdentifierMigration(response: LLMResponse, state: StateManager): void {
-  const personId = response.request.data.person_id as string;
-  if (!personId) {
-    console.error("[handlePersonIdentifierMigration] Missing person_id in request data");
-    return;
-  }
-
-  const human = state.getHuman();
-  const person = human.people.find(p => p.id === personId);
-  if (!person) {
-    console.error(`[handlePersonIdentifierMigration] Person not found: ${personId}`);
-    return;
-  }
-
-  const result = response.parsed as { identifiers?: Array<{ type: string; value: string; is_primary?: boolean }> } | undefined;
-  if (!result?.identifiers || !Array.isArray(result.identifiers) || result.identifiers.length === 0) {
-    console.error(`[handlePersonIdentifierMigration] Invalid or empty identifiers for ${person.name}`);
-    return;
-  }
-
-  const hasName = result.identifiers.some(i => i.value === person.name);
-  if (!hasName) {
-    result.identifiers.unshift({ type: "nickname", value: person.name });
-  }
-
-  const hasPrimary = result.identifiers.some(i => i.is_primary);
-  if (!hasPrimary) {
-    result.identifiers[0].is_primary = true;
-  }
-
-  const identifiers: PersonIdentifier[] = result.identifiers.map(i => ({
-    type: i.type,
-    value: i.value,
-    ...(i.is_primary ? { is_primary: i.is_primary } : {}),
-  }));
-
-  state.human_person_upsert({
-    ...person,
-    identifiers,
-    last_updated: new Date().toISOString(),
-  });
-
-  console.log(`[handlePersonIdentifierMigration] Migrated ${identifiers.length} identifier(s) for ${person.name}`);
-}
+import { handleDocumentSegmentation } from "./document-segmentation.js";
 
 export const handlers: Record<LLMNextStep, ResponseHandler> = {
   handlePersonaResponse,
   handlePersonaGeneration,
-  handlePersonaDescriptions,
   handleFactFind,
   handleHumanTopicScan,
   handleHumanPersonScan,
@@ -88,7 +40,7 @@ export const handlers: Record<LLMNextStep, ResponseHandler> = {
   handleRoomResponse,
   handleRoomJudge,
   handlePersonaPreview,
-  [LLMNextStep.HandlePersonIdentifierMigration]: handlePersonIdentifierMigration,
   [LLMNextStep.HandleTopicValidate]: handleDedupCurate,
   [LLMNextStep.HandleReflectionCritic]: handleReflectionCritic,
+  [LLMNextStep.HandleDocumentSegmentation]: handleDocumentSegmentation,
 };

package/src/core/handlers/persona-generation.ts

@@ -4,7 +4,7 @@ import {
   type PersonaTopic,
 } from "../types.js";
 import type { StateManager } from "../state-manager.js";
-import type { PersonaGenerationResult, PersonaDescriptionsResult } from "../../prompts/generation/types.js";
+import type { PersonaGenerationResult } from "../../prompts/generation/types.js";
 import type { TraitResult } from "../../prompts/persona/types.js";
 import { orchestratePersonaGeneration, type PartialPersona } from "../orchestrators/index.js";
 
@@ -111,33 +111,6 @@ export function handlePersonaGeneration(response: LLMResponse, state: StateManag
   console.log(`[handlePersonaGeneration] Orchestrated: ${personaDisplayName}`);
 }
 
-export function handlePersonaDescriptions(response: LLMResponse, state: StateManager): void {
-  const personaId = response.request.data.personaId as string;
-  const personaDisplayName = response.request.data.personaDisplayName as string;
-  if (!personaId) {
-    console.error("[handlePersonaDescriptions] No personaId in request data");
-    return;
-  }
-
-  const result = response.parsed as PersonaDescriptionsResult | undefined;
-  if (!result) {
-    console.error("[handlePersonaDescriptions] No parsed result");
-    return;
-  }
-
-  if (result.no_change) {
-    console.log(`[handlePersonaDescriptions] No change needed for ${personaDisplayName}`);
-    return;
-  }
-
-  state.persona_update(personaId, {
-    short_description: result.short_description,
-    long_description: result.long_description,
-    last_updated: new Date().toISOString(),
-  });
-  console.log(`[handlePersonaDescriptions] Updated descriptions for ${personaDisplayName}`);
-}
-
 export function handlePersonaTraitExtraction(response: LLMResponse, state: StateManager): void {
   const personaId = response.request.data.personaId as string;
   const personaDisplayName = response.request.data.personaDisplayName as string;

package/src/core/handlers/rewrite.ts

@@ -14,7 +14,8 @@ import type {
   RewriteResult,
   RewriteSubjectMatch,
 } from "../../prompts/ceremony/types.js";
-import { buildRewritePrompt } from "../../prompts/ceremony/rewrite.js";
+import { buildPersonRewriteSplitPrompt } from "../../prompts/ceremony/people-rewrite.js";
+import { buildTopicRewriteSplitPrompt } from "../../prompts/ceremony/topic-rewrite.js";
 import { getEmbeddingService, getItemEmbeddingText } from "../embedding-service.js";
 
 import { searchHumanData } from "../human-data-manager.js";
@@ -79,12 +80,10 @@ export async function handleRewriteScan(response: LLMResponse, state: StateManag
     }
   }
 
-  // Build Phase 2 prompt and queue it
-  const prompt = buildRewritePrompt({
-    item: currentItem,
-    itemType,
-    subjects: subjectMatches,
-  });
+  const splitData = { item: currentItem, itemType, subjects: subjectMatches };
+  const prompt = itemType === "person"
+    ? buildPersonRewriteSplitPrompt(splitData)
+    : buildTopicRewriteSplitPrompt(splitData);
 
   state.queue_enqueue({
     type: LLMRequestType.JSON,
@@ -125,6 +124,11 @@ export async function handleRewriteRewrite(response: LLMResponse, state: StateMa
   const human = state.getHuman();
   const now = new Date().toISOString();
 
+  const originalItem = itemType === "topic"
+    ? human.topics.find(t => t.id === itemId)
+    : human.people.find(p => p.id === itemId);
+  const originalCategory = itemType === "topic" ? (originalItem as Topic | undefined)?.category : undefined;
+
   const allItems: DataItemBase[] = [
     ...human.topics, ...human.people,
   ];
@@ -228,11 +232,11 @@ export async function handleRewriteRewrite(response: LLMResponse, state: StateMa
     switch (item.type) {
       case "topic": {
         if (!item.category) {
-          console.warn(`[handleRewriteRewrite] New topic "${item.name}" missing category — defaulting to "Interest"`);
+          console.warn(`[handleRewriteRewrite] New topic "${item.name}" missing category — inheriting from original (${originalCategory ?? "Interest"})`);
         }
         const topic: Topic = {
           ...baseFields,
-          category: item.category ?? "Interest",
+          category: item.category ?? originalCategory ?? "Interest",
           exposure_current: 0.5,
           exposure_desired: 0.5,
         };

package/src/core/handlers/utils.ts

@@ -1,15 +1,8 @@
 import type { Message, RoomMessage, LLMResponse } from "../types.js";
 import type { StateManager } from "../state-manager.js";
 
-export function getMessageContent(msg: { content?: string; verbal_response?: string; action_response?: string }): string {
-  if (msg.content) return msg.content;
-  // Legacy fallback for data not yet migrated on disk
-  // TODO(v1.0.0): Remove legacy verbal_response/action_response fallback
-  const legacy = msg as { verbal_response?: string; action_response?: string };
-  const parts: string[] = [];
-  if (legacy.action_response) parts.push(`_${legacy.action_response}_`);
-  if (legacy.verbal_response) parts.push(legacy.verbal_response);
-  return parts.join('\n\n');
+export function getMessageContent(msg: { content?: string }): string {
+  return msg.content ?? '';
 }
 
 export function normalizeRoomMessages(messages: RoomMessage[], state: StateManager): Message[] {

package/src/core/heartbeat-manager.ts

@@ -143,7 +143,7 @@ export async function queueEiHeartbeat(
   }
 
   const activePersonas = personas
-    .filter((p) => !p.is_archived && !p.is_paused && p.id !== "ei")
+    .filter((p) => !p.is_archived && !p.is_paused && !p.is_static && p.id !== "ei")
     .map((p) => {
       const msgs = sm.messages_get(p.id);
       const lastHuman = [...msgs].reverse().find((m) => m.role === "human");
@@ -169,7 +169,7 @@ export async function queueEiHeartbeat(
   }
 
   const personasWithPendingUpdate = personas.filter(
-    (p) => !p.is_archived && !p.is_paused && p.id !== "ei" && p.pending_update?.critique
+    (p) => !p.is_archived && !p.is_paused && !p.is_static && p.id !== "ei" && p.pending_update?.critique
   );
   for (const p of personasWithPendingUpdate) {
     items.push({
@@ -217,8 +217,8 @@ export async function queueHeartbeatCheck(sm: StateManager, personaId: string, i
   console.log(`[HeartbeatCheck ${persona.display_name}] Queueing heartbeat check (model: ${model})`);
   const human = sm.getHuman();
    const history = sm.messages_get(personaId);
-   const contextWindowHours = persona.context_window_hours ?? human.settings?.default_context_window_hours ?? 8;
-   const contextHistory = filterMessagesForContext(history, persona.context_boundary, contextWindowHours);
+   const contextWindowMs = persona.context_window_ms ?? human.settings?.default_context_window_ms ?? 28800000;
+   const contextHistory = filterMessagesForContext(history, persona.context_boundary, contextWindowMs);
 
   if (personaId === "ei") {
     await queueEiHeartbeat(sm, human, contextHistory, isTUI);
@@ -244,7 +244,7 @@ export async function queueHeartbeatCheck(sm: StateManager, personaId: string, i
       name: persona.display_name,
       traits: persona.traits,
       topics: persona.topics,
-      has_pending_update: !!persona.pending_update,
+      pending_update: persona.pending_update,
     },
     human: {
       topics: sortByEngagementGap(filteredHuman.topics).slice(0, 5),