ei-tui 0.1.18 → 0.1.19

package/package.json

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

package/src/core/handlers/index.ts

@@ -29,8 +29,13 @@ import type {
   PersonaExpireResult, 
   PersonaExploreResult,
   DescriptionCheckResult,
+  RewriteItemType,
+  RewriteScanResult,
+  RewriteResult,
+  RewriteSubjectMatch,
 } from "../../prompts/ceremony/types.js";
-import { 
+import { buildRewritePrompt } from "../../prompts/ceremony/rewrite.js";
+import {
   orchestratePersonaGeneration, 
   queueItemMatch, 
   queueItemUpdate,
@@ -59,6 +64,30 @@ import { crossFind } from "../utils/index.js";
 
 export type ResponseHandler = (response: LLMResponse, state: StateManager) => void | Promise<void>;
 
+// =============================================================================
+// REWRITE HANDLER INJECTION
+// searchHumanData lives on Processor — inject it at startup to avoid circular deps.
+// Same pattern as registerReadMemoryExecutor in tools/index.ts.
+// =============================================================================
+
+type SearchHumanDataFn = (
+  query: string,
+  options?: { types?: Array<'fact' | 'trait' | 'topic' | 'person' | 'quote'>; limit?: number }
+) => Promise<{
+  facts: Fact[];
+  traits: Trait[];
+  topics: Topic[];
+  people: Person[];
+  quotes: Quote[];
+}>;
+
+let _searchHumanData: SearchHumanDataFn | null = null;
+
+/** Called by Processor at startup to inject searchHumanData for rewrite handlers. */
+export function registerSearchHumanData(fn: SearchHumanDataFn): void {
+  _searchHumanData = fn;
+}
+
 function splitMessagesByTimestamp(
   messages: Message[], 
   analyzeFromTimestamp: string | null
@@ -1117,6 +1146,287 @@ function handlePersonaTopicUpdate(response: LLMResponse, state: StateManager): v
 
 
 
+// =============================================================================
+// REWRITE HANDLERS (Ceremony — fire-and-forget)
+// =============================================================================
+
+/**
+ * handleRewriteScan — Phase 1 of Rewrite.
+ * LLM returns an array of subject strings found in the bloated item.
+ * For each subject we search the knowledge base, then queue Phase 2.
+ */
+async function handleRewriteScan(response: LLMResponse, state: StateManager): Promise<void> {
+  const itemId = response.request.data.itemId as string;
+  const itemType = response.request.data.itemType as RewriteItemType;
+  const rewriteModel = response.request.data.rewriteModel as string;
+
+  if (!itemId || !itemType) {
+    console.error("[handleRewriteScan] Missing itemId or itemType in request data");
+    return;
+  }
+
+  const subjects = response.parsed as RewriteScanResult | undefined;
+  if (!subjects || !Array.isArray(subjects) || subjects.length === 0) {
+    console.log(`[handleRewriteScan] No extra subjects found for ${itemType} "${itemId}" — item is cohesive`);
+    return;
+  }
+
+  if (!_searchHumanData) {
+    console.error("[handleRewriteScan] searchHumanData not injected — cannot search for matches");
+    return;
+  }
+
+  // Re-read the item from current state (it may have changed since scan was queued)
+  const human = state.getHuman();
+  const allItems: DataItemBase[] = [
+    ...human.facts, ...human.traits, ...human.topics, ...human.people,
+  ];
+  const currentItem = allItems.find(i => i.id === itemId);
+  if (!currentItem) {
+    console.warn(`[handleRewriteScan] Item ${itemId} no longer exists — skipping rewrite`);
+    return;
+  }
+
+  // Search for matches per subject, excluding the original item
+  const subjectMatches: RewriteSubjectMatch[] = [];
+  for (const searchTerm of subjects) {
+    try {
+      const results = await _searchHumanData(searchTerm, {
+        types: ["fact", "trait", "topic", "person"],
+        limit: 4,  // fetch 4 so we can exclude original and still have 3
+      });
+      const allMatches: DataItemBase[] = [
+        ...results.facts, ...results.traits, ...results.topics, ...results.people,
+      ].filter(m => m.id !== itemId);  // exclude original
+      subjectMatches.push({ searchTerm, matches: allMatches.slice(0, 3) });
+    } catch (err) {
+      console.warn(`[handleRewriteScan] Search failed for "${searchTerm}":`, err);
+      subjectMatches.push({ searchTerm, matches: [] });
+    }
+  }
+
+  // Build Phase 2 prompt and queue it
+  const prompt = buildRewritePrompt({
+    item: currentItem,
+    itemType,
+    subjects: subjectMatches,
+  });
+
+  state.queue_enqueue({
+    type: LLMRequestType.JSON,
+    priority: LLMPriority.Normal,
+    system: prompt.system,
+    user: prompt.user,
+    next_step: LLMNextStep.HandleRewriteRewrite,
+    model: rewriteModel,
+    data: {
+      itemId,
+      itemType,
+    },
+  });
+
+  console.log(`[handleRewriteScan] Queued Phase 2 for ${itemType} "${currentItem.name}" with ${subjectMatches.length} subject(s)`);
+}
+
+/**
+ * handleRewriteRewrite — Phase 2 of Rewrite.
+ * LLM returns { existing: [...], new: [...] }.
+ * Upsert existing items by id, create new items with defensive defaults + embeddings.
+ */
+async function handleRewriteRewrite(response: LLMResponse, state: StateManager): Promise<void> {
+  const itemId = response.request.data.itemId as string;
+  const itemType = response.request.data.itemType as RewriteItemType;
+
+  if (!itemId || !itemType) {
+    console.error("[handleRewriteRewrite] Missing itemId or itemType in request data");
+    return;
+  }
+
+  const result = response.parsed as RewriteResult | undefined;
+  if (!result || (!result.existing?.length && !result.new?.length)) {
+    console.log(`[handleRewriteRewrite] No changes returned for ${itemType} "${itemId}"`);
+    return;
+  }
+
+  const human = state.getHuman();
+  const now = new Date().toISOString();
+
+  // Look up the original item to inherit persona_groups
+  const allItems: DataItemBase[] = [
+    ...human.facts, ...human.traits, ...human.topics, ...human.people,
+  ];
+  const originalItem = allItems.find(i => i.id === itemId);
+  const inheritedGroups = originalItem?.persona_groups;
+
+  // Helper: resolve actual type from existing records (don't trust LLM's type field)
+  const resolveExistingType = (id: string): RewriteItemType | null => {
+    if (human.facts.find(f => f.id === id)) return "fact";
+    if (human.traits.find(t => t.id === id)) return "trait";
+    if (human.topics.find(t => t.id === id)) return "topic";
+    if (human.people.find(p => p.id === id)) return "person";
+    return null;
+  };
+
+  let existingCount = 0;
+  let newCount = 0;
+
+  // --- Process existing items ---
+  for (const item of result.existing ?? []) {
+    if (!item.id || !item.name || !item.description) {
+      console.warn(`[handleRewriteRewrite] Skipping existing item with missing fields: ${JSON.stringify(item).slice(0, 100)}`);
+      continue;
+    }
+
+    // Resolve type from actual records, not from LLM response
+    const resolvedType = resolveExistingType(item.id);
+    if (!resolvedType) {
+      console.warn(`[handleRewriteRewrite] Existing item id "${item.id}" not found in human data — skipping`);
+      continue;
+    }
+
+    let embedding: number[] | undefined;
+    try {
+      const embeddingService = getEmbeddingService();
+      const text = getItemEmbeddingText({ name: item.name, description: item.description });
+      embedding = await embeddingService.embed(text);
+    } catch (err) {
+      console.warn(`[handleRewriteRewrite] Failed to compute embedding for existing ${resolvedType} "${item.name}":`, err);
+    }
+
+    switch (resolvedType) {
+      case "fact": {
+        const existing = human.facts.find(f => f.id === item.id)!;
+        state.human_fact_upsert({
+          ...existing,
+          name: item.name,
+          description: item.description,
+          sentiment: item.sentiment ?? existing.sentiment,
+          last_updated: now,
+          embedding,
+        });
+        break;
+      }
+      case "trait": {
+        const existing = human.traits.find(t => t.id === item.id)!;
+        state.human_trait_upsert({
+          ...existing,
+          name: item.name,
+          description: item.description,
+          sentiment: item.sentiment ?? existing.sentiment,
+          strength: item.strength ?? existing.strength,
+          last_updated: now,
+          embedding,
+        });
+        break;
+      }
+      case "topic": {
+        const existing = human.topics.find(t => t.id === item.id)!;
+        state.human_topic_upsert({
+          ...existing,
+          name: item.name,
+          description: item.description,
+          sentiment: item.sentiment ?? existing.sentiment,
+          last_updated: now,
+          embedding,
+        });
+        break;
+      }
+      case "person": {
+        const existing = human.people.find(p => p.id === item.id)!;
+        state.human_person_upsert({
+          ...existing,
+          name: item.name,
+          description: item.description,
+          sentiment: item.sentiment ?? existing.sentiment,
+          last_updated: now,
+          embedding,
+        });
+        break;
+      }
+    }
+    existingCount++;
+  }
+
+  // --- Process new items ---
+  for (const item of result.new ?? []) {
+    if (!item.type || !item.name || !item.description) {
+      console.warn(`[handleRewriteRewrite] Skipping new item with missing fields: ${JSON.stringify(item).slice(0, 100)}`);
+      continue;
+    }
+
+    let embedding: number[] | undefined;
+    try {
+      const embeddingService = getEmbeddingService();
+      const text = getItemEmbeddingText({ name: item.name, description: item.description });
+      embedding = await embeddingService.embed(text);
+    } catch (err) {
+      console.warn(`[handleRewriteRewrite] Failed to compute embedding for new ${item.type} "${item.name}":`, err);
+    }
+
+    const baseFields = {
+      id: crypto.randomUUID(),
+      name: item.name,
+      description: item.description,
+      sentiment: item.sentiment ?? 0,
+      last_updated: now,
+      learned_by: "ei",
+      persona_groups: inheritedGroups,
+      embedding,
+    };
+
+    switch (item.type) {
+      case "fact": {
+        const fact: Fact = {
+          ...baseFields,
+          validated: ValidationLevel.None,
+          validated_date: now,
+        };
+        state.human_fact_upsert(fact);
+        break;
+      }
+      case "trait": {
+        const trait: Trait = {
+          ...baseFields,
+          strength: item.strength ?? 0.5,
+        };
+        state.human_trait_upsert(trait);
+        break;
+      }
+      case "topic": {
+        if (!item.category) {
+          console.warn(`[handleRewriteRewrite] New topic "${item.name}" missing category — defaulting to "Interest"`);
+        }
+        const topic: Topic = {
+          ...baseFields,
+          category: item.category ?? "Interest",
+          exposure_current: 0.5,
+          exposure_desired: 0.5,
+        };
+        state.human_topic_upsert(topic);
+        break;
+      }
+      case "person": {
+        if (!item.relationship) {
+          console.warn(`[handleRewriteRewrite] New person "${item.name}" missing relationship — defaulting to "Unknown"`);
+        }
+        const person: Person = {
+          ...baseFields,
+          relationship: item.relationship ?? "Unknown",
+          exposure_current: 0.5,
+          exposure_desired: 0.5,
+        };
+        state.human_person_upsert(person);
+        break;
+      }
+      default:
+        console.warn(`[handleRewriteRewrite] Unknown type "${item.type}" for new item "${item.name}" — skipping`);
+    }
+    newCount++;
+  }
+
+  console.log(`[handleRewriteRewrite] Complete for ${itemType} "${itemId}": ${existingCount} existing updated, ${newCount} new created`);
+}
+
 /**
  * handleToolSynthesis — second LLM call in the tool flow.
  * The QueueProcessor already injected tool history into messages and got the
@@ -1149,4 +1459,6 @@ export const handlers: Record<LLMNextStep, ResponseHandler> = {
   handlePersonaExplore,
   handleDescriptionCheck,
   handleToolSynthesis,
+  handleRewriteScan,
+  handleRewriteRewrite,
 };

package/src/core/orchestrators/ceremony.ts

@@ -10,7 +10,7 @@ import {
   type ExtractionOptions,
 } from "./human-extraction.js";
 import { queuePersonaTopicScan, type PersonaTopicContext } from "./persona-topics.js";
-import { buildPersonaExpirePrompt, buildPersonaExplorePrompt, buildDescriptionCheckPrompt } from "../../prompts/ceremony/index.js";
+import { buildPersonaExpirePrompt, buildPersonaExplorePrompt, buildDescriptionCheckPrompt, buildRewriteScanPrompt, type RewriteItemType } from "../../prompts/ceremony/index.js";
 
 export function isNewDay(lastCeremony: string | undefined, now: Date): boolean {
   if (!lastCeremony) return true;
@@ -227,6 +227,10 @@ export function handleCeremonyProgress(state: StateManager): void {
 
   // Dedup phase: log near-duplicate human entities (dry-run only, no mutations)
   runDedupPhase(state);
+
+  // Rewrite phase: fire-and-forget scans for bloated human data items
+  // No ceremony_progress gating — Expire/Explore only touch persona topics, zero overlap
+  queueRewritePhase(state);
   
   // Expire phase: queue LLM calls for each active persona
   // handlePersonaExpire already chains to Explore → DescriptionCheck
@@ -574,3 +578,78 @@ export function runDedupPhase(state: StateManager): void {
 
   console.log(`[ceremony:dedup] Done. ${totalCandidates} total candidate pair(s) found.`);
 }
+
+// =============================================================================
+// REWRITE PHASE (fire-and-forget — queues Low-priority Phase 1 scans)
+// =============================================================================
+
+const REWRITE_DESCRIPTION_THRESHOLD = 750;
+
+/**
+ * Queue Phase 1 "scan" for every human data item whose description exceeds the
+ * threshold. Gated on rewrite_model being set in HumanSettings.
+ * 
+ * Fire-and-forget: no ceremony_progress, no blocking. Expire/Explore proceed
+ * immediately since they only touch persona topics (zero overlap with human data).
+ * Phase 2 items enqueue at Normal priority, naturally processing before more
+ * Low-priority Phase 1 scans.
+ */
+export function queueRewritePhase(state: StateManager): void {
+  const human = state.getHuman();
+  const rewriteModel = human.settings?.rewrite_model;
+
+  if (!rewriteModel) {
+    console.log("[ceremony:rewrite] rewrite_model not set — skipping rewrite phase");
+    return;
+  }
+
+  const itemsToScan: Array<{ item: DataItemBase; type: RewriteItemType }> = [];
+
+  for (const fact of human.facts) {
+    if ((fact.description?.length ?? 0) > REWRITE_DESCRIPTION_THRESHOLD) {
+      itemsToScan.push({ item: fact, type: "fact" });
+    }
+  }
+  for (const trait of human.traits) {
+    if ((trait.description?.length ?? 0) > REWRITE_DESCRIPTION_THRESHOLD) {
+      itemsToScan.push({ item: trait, type: "trait" });
+    }
+  }
+  for (const topic of human.topics) {
+    if ((topic.description?.length ?? 0) > REWRITE_DESCRIPTION_THRESHOLD) {
+      itemsToScan.push({ item: topic, type: "topic" });
+    }
+  }
+  for (const person of human.people) {
+    if ((person.description?.length ?? 0) > REWRITE_DESCRIPTION_THRESHOLD) {
+      itemsToScan.push({ item: person, type: "person" });
+    }
+  }
+
+  if (itemsToScan.length === 0) {
+    console.log("[ceremony:rewrite] No items above threshold — nothing to rewrite");
+    return;
+  }
+
+  console.log(`[ceremony:rewrite] Found ${itemsToScan.length} item(s) above ${REWRITE_DESCRIPTION_THRESHOLD} chars — queueing Phase 1 scans`);
+
+  for (const { item, type } of itemsToScan) {
+    const prompt = buildRewriteScanPrompt({ item, itemType: type });
+
+    state.queue_enqueue({
+      type: LLMRequestType.JSON,
+      priority: LLMPriority.Low,
+      system: prompt.system,
+      user: prompt.user,
+      next_step: LLMNextStep.HandleRewriteScan,
+      model: rewriteModel,
+      data: {
+        itemId: item.id,
+        itemType: type,
+        rewriteModel,  // pass through so Phase 1 handler can queue Phase 2 with the same model
+      },
+    });
+  }
+
+  console.log(`[ceremony:rewrite] Queued ${itemsToScan.length} Phase 1 scan(s) at Low priority`);
+}

package/src/core/orchestrators/index.ts

@@ -19,6 +19,7 @@ export {
   queueExplorePhase,
   queueDescriptionCheck,
   runHumanCeremony,
+  queueRewritePhase,
 } from "./ceremony.js";
 export {
   queuePersonaTopicScan,

package/src/core/processor.ts

@@ -33,7 +33,7 @@ import { remoteSync } from "../storage/remote.js";
 import { yoloMerge } from "../storage/merge.js";
 import { StateManager } from "./state-manager.js";
 import { QueueProcessor } from "./queue-processor.js";
-import { handlers } from "./handlers/index.js";
+import { handlers, registerSearchHumanData } from "./handlers/index.js";
 import {
   buildResponsePrompt,
   buildPersonaTraitExtractionPrompt,
@@ -216,6 +216,8 @@ export class Processor {
     this.bootstrapTools();
     // Register read_memory executor (injected to avoid circular deps)
     registerReadMemoryExecutor(createReadMemoryExecutor(this.searchHumanData.bind(this)));
+    // Inject searchHumanData for rewrite handlers (same pattern as read_memory)
+    registerSearchHumanData(this.searchHumanData.bind(this));
     // file_read is Node-only — dynamic import to keep node:fs/promises out of the web bundle
     if (this.isTUI) {
       registerFileReadExecutor();
@@ -1085,6 +1087,10 @@ export class Processor {
         this.interface.onQuoteAdded?.();
       }
 
+      if (response.request.next_step === LLMNextStep.HandleRewriteRewrite) {
+        this.interface.onHumanUpdated?.();
+      }
+
       if (response.request.data.ceremony_progress) {
         handleCeremonyProgress(this.stateManager);
       }

package/src/core/types.ts

@@ -54,6 +54,8 @@ export enum LLMNextStep {
   // data.toolHistory: serialized LLMHistoryMessage[] (assistant + tool result messages)
   // data.originalNextStep: the next_step value from the originating request
   HandleToolSynthesis = "handleToolSynthesis",
+  HandleRewriteScan = "handleRewriteScan",
+  HandleRewriteRewrite = "handleRewriteRewrite",
 }
 // =============================================================================
 // DATA ITEMS
@@ -244,6 +246,7 @@ export interface BackupConfig {
 export interface HumanSettings {
   default_model?: string;
   oneshot_model?: string;           // Model for AI-assist (wand) requests; falls back to default_model
+  rewrite_model?: string;           // Model for rewrite ceremony step; must be capable (Sonnet/Opus class). Unset = rewrite disabled.
   queue_paused?: boolean;
   skip_quote_delete_confirm?: boolean;
   name_display?: string;

package/src/prompts/ceremony/index.ts

@@ -1,6 +1,7 @@
 export { buildPersonaExpirePrompt } from "./expire.js";
 export { buildPersonaExplorePrompt } from "./explore.js";
 export { buildDescriptionCheckPrompt } from "./description-check.js";
+export { buildRewriteScanPrompt, buildRewritePrompt } from "./rewrite.js";
 export type {
   PersonaExpirePromptData,
   PersonaExpireResult,
@@ -8,4 +9,10 @@ export type {
   PersonaExploreResult,
   DescriptionCheckPromptData,
   DescriptionCheckResult,
+  RewriteItemType,
+  RewriteScanPromptData,
+  RewriteScanResult,
+  RewriteSubjectMatch,
+  RewritePromptData,
+  RewriteResult,
 } from "./types.js";

package/src/prompts/ceremony/rewrite.ts

@@ -0,0 +1,166 @@
+import type { RewriteScanPromptData, RewritePromptData } from "./types.js";
+
+// =============================================================================
+// PHASE 1: SCAN — Identify distinct subjects in a bloated item
+// =============================================================================
+
+export function buildRewriteScanPrompt(data: RewriteScanPromptData): { system: string; user: string } {
+  const typeLabel = data.itemType.charAt(0).toUpperCase() + data.itemType.slice(1);
+
+  const system = `You are auditing a personal knowledge base. A single ${typeLabel} record has grown too large because unrelated information was repeatedly appended to it over time. The record's Name suggests its intended subject, but its Description now covers many additional, unrelated subjects.
+
+Your job: identify the **additional** subjects buried in this record that do NOT belong under the record's Name.
+
+Rules:
+- Do NOT include the record's primary subject (what its Name describes) — only the extra, unrelated subjects.
+- Each subject should be a succinct phrase (2-8 words) that could serve as a search query.
+- Be specific. "Technical preferences" is too vague. "TypeScript coding conventions" is better.
+- If the record is actually cohesive and on-topic despite its length, return an empty array.
+
+Return a raw JSON array of strings. No markdown fencing, no commentary, no explanation. Just the array.
+
+Example — a Fact named "Job" whose description also discusses vim keybindings, git conventions, and AI tooling:
+["vim keybindings and editor configuration", "git and GitHub workflow conventions", "AI coding assistant preferences"]`;
+
+  const user = JSON.stringify(stripEmbedding(data.item), null, 2);
+
+  return { system, user };
+}
+
+// =============================================================================
+// PHASE 2: REWRITE — Reorganize data across existing and new items
+// =============================================================================
+
+export function buildRewritePrompt(data: RewritePromptData): { system: string; user: string } {
+  const typeLabel = data.itemType.charAt(0).toUpperCase() + data.itemType.slice(1);
+
+  const system = `You are reorganizing a personal knowledge base. A ${typeLabel} record has become a catch-all for several unrelated subjects. An earlier analysis identified the extra subjects, and we searched our knowledge base for potentially matching existing records.
+
+The search results under each subject are our **best guesses** — they may not be accurate matches. Only merge data into an existing record if the subject matter genuinely overlaps. Similar names with different meanings should produce a NEW record instead.
+
+Your job:
+1. **Update existing records**: For subjects that match an existing record, incorporate the relevant data from the original entry into that record's description. Preserve the existing record's "id", "name", and "type".
+2. **Create new records**: For subjects with no appropriate match among the search results, create a new record.
+3. **Slim the original**: Remove all data from the original record that now lives elsewhere. The original should contain ONLY information directly relevant to its Name.
+
+Return raw JSON with exactly two keys. No markdown fencing, no commentary. Just the JSON object:
+{
+  "existing": [ /* updated records, including the slimmed-down original */ ],
+  "new": [ /* brand-new records for subjects with no match */ ]
+}
+
+Record format for "existing" entries (MUST include "id" and "type"):
+${buildExistingExamples()}
+
+Record format for "new" entries (NO "id" field — the system assigns one):
+${buildNewExamples()}
+
+Rules:
+- The original record (id: "${data.item.id}") MUST appear in "existing", slimmed down.
+- Descriptions should be concise — ideally under 300 characters, never over 500.
+- Preserve sentiment, strength, confidence, and other numeric values from the source record where applicable.
+- "type" must be one of: "fact", "trait", "topic", "person".
+- Topics MUST include "category" — one of: Interest, Goal, Dream, Conflict, Concern, Fear, Hope, Plan, Project.
+- People MUST include "relationship" — a short label like "coworker", "friend", "mentor", etc.
+- Traits MUST include "strength" (0.0-1.0).
+- Do NOT invent information. Only redistribute what exists in the original record.`;
+
+  const subjects = data.subjects.map(s => ({
+    search_term: s.searchTerm,
+    matches: s.matches.map(m => stripEmbedding(m)),
+  }));
+
+  const userPayload = {
+    original: stripEmbedding(data.item),
+    original_type: data.itemType,
+    subjects,
+  };
+
+  const user = JSON.stringify(userPayload, null, 2);
+
+  return { system, user };
+}
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+/** Strip embedding arrays from items before putting them in prompts — they're huge and useless to the LLM. */
+function stripEmbedding<T extends { embedding?: unknown }>(item: T): Omit<T, "embedding"> {
+  const { embedding: _, ...rest } = item;
+  return rest as Omit<T, "embedding">;
+}
+
+function buildExistingExamples(): string {
+  return `Fact:
+{
+  "id": "existing-uuid",
+  "type": "fact",
+  "name": "Record Name",
+  "description": "Updated description with incorporated data"
+}
+
+Trait:
+{
+  "id": "existing-uuid",
+  "type": "trait",
+  "name": "Trait Name",
+  "description": "Updated trait description",
+  "strength": 0.7
+}
+
+Topic:
+{
+  "id": "existing-uuid",
+  "type": "topic",
+  "name": "Topic Name",
+  "description": "Updated topic description",
+  "category": "Interest"
+}
+
+Person:
+{
+  "id": "existing-uuid",
+  "type": "person",
+  "name": "Person Name",
+  "description": "Updated person description",
+  "relationship": "coworker"
+}`;
+}
+
+function buildNewExamples(): string {
+  return `Fact:
+{
+  "type": "fact",
+  "name": "New Subject Name",
+  "description": "Concise description of this subject",
+  "sentiment": 0.0
+}
+
+Trait:
+{
+  "type": "trait",
+  "name": "New Trait Name",
+  "description": "Concise trait description",
+  "sentiment": 0.0,
+  "strength": 0.5
+}
+
+Topic:
+{
+  "type": "topic",
+  "name": "New Topic Name",
+  "description": "Concise topic description",
+  "sentiment": 0.0,
+  "category": "Interest"
+}
+
+Person:
+{
+  "type": "person",
+  "name": "New Person Name",
+  "description": "Concise person description",
+  "sentiment": 0.0,
+  "relationship": "friend"
+}`;
+}

package/src/prompts/ceremony/types.ts

@@ -1,4 +1,4 @@
-import type { Trait, PersonaTopic } from "../../core/types.js";
+import type { Trait, PersonaTopic, DataItemBase } from "../../core/types.js";
 
 export interface PersonaExpirePromptData {
   persona_name: string;
@@ -40,3 +40,58 @@ export interface DescriptionCheckResult {
   should_update: boolean;
   reason?: string;
 }
+
+// =============================================================================
+// REWRITE (Item Reorganization)
+// =============================================================================
+
+export type RewriteItemType = "fact" | "trait" | "topic" | "person";
+
+/** Phase 1 input: the bloated item to scan for extra subjects. */
+export interface RewriteScanPromptData {
+  item: DataItemBase;
+  itemType: RewriteItemType;
+}
+
+/** Phase 1 output: array of subject strings (parsed from LLM JSON response). */
+export type RewriteScanResult = string[];
+
+/** A single subject and the read_memory matches found for it. */
+export interface RewriteSubjectMatch {
+  searchTerm: string;
+  matches: DataItemBase[];  // Top 3 from searchHumanData, may be empty
+}
+
+/** Phase 2 input: the bloated item + all subject matches. */
+export interface RewritePromptData {
+  item: DataItemBase;
+  itemType: RewriteItemType;
+  subjects: RewriteSubjectMatch[];
+}
+
+/** Phase 2 output: existing items to upsert + new items to create. */
+export interface RewriteResult {
+  existing: Array<{
+    id: string;
+    type: RewriteItemType;
+    name: string;
+    description: string;
+    sentiment?: number;
+    strength?: number;        // traits
+    exposure_current?: number; // topics, people
+    exposure_desired?: number; // topics, people
+    relationship?: string;     // people
+    category?: string;          // topics
+  }>;
+  new: Array<{
+    type: RewriteItemType;
+    name: string;
+    description: string;
+    sentiment?: number;
+    strength?: number;
+    exposure_current?: number;
+    exposure_desired?: number;
+    relationship?: string;
+    category?: string;
+  }>;
+}

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

@@ -501,6 +501,8 @@ export function humanFromYAML(yamlContent: string): HumanYAMLResult {
 
 interface EditableSettingsData {
   default_model?: string | null;
+  oneshot_model?: string | null;
+  rewrite_model?: string | null;
   time_mode?: "24h" | "12h" | "local" | "utc" | null;
   name_display?: string | null;
   ceremony?: {
@@ -531,6 +533,8 @@ export function settingsToYAML(settings: HumanSettings | undefined): string {
   // Always show all editable fields, using null for unset values so YAML displays them
   const data: EditableSettingsData = {
     default_model: settings?.default_model ?? null,
+    oneshot_model: settings?.oneshot_model ?? null,
+    rewrite_model: settings?.rewrite_model ?? null,
     time_mode: settings?.time_mode ?? null,
     name_display: settings?.name_display ?? null,
     ceremony: {
@@ -614,6 +618,8 @@ export function settingsFromYAML(yamlContent: string, original: HumanSettings |
   return {
     ...original,
     default_model: nullToUndefined(data.default_model),
+    oneshot_model: nullToUndefined(data.oneshot_model),
+    rewrite_model: nullToUndefined(data.rewrite_model),
     time_mode: nullToUndefined(data.time_mode),
     name_display: nullToUndefined(data.name_display),
     ceremony,