ei-tui 1.1.0 → 1.3.0

package/src/prompts/response/sections.ts

@@ -6,6 +6,7 @@
 import type { PersonaTrait, Quote, PersonaTopic } from "../../core/types.js";
 import type { ResponsePromptData, TemporalAnchor } from "./types.js";
 import { formatTimestamp } from "../../core/format-utils.js";
+import { partitionTraits, bucketTraits } from "../trait-utils.js";
 
 const DESCRIPTION_MAX_CHARS = 500;
 
@@ -69,25 +70,35 @@ export function buildGuidelinesSection(personaName: string): string {
 // TRAITS SECTION
 // =============================================================================
 
+const TRAIT_BUCKETS = [
+  { min: 90, max: 100, header: "### Core Expression\nThese define you. They should be evident in every response." },
+  { min: 66, max: 89,  header: "### Strong Tendencies\nFrequent and traceable, but not in every sentence." },
+  { min: 36, max: 65,  header: "### Noticeable in Casual Messages\nPresent but not dominating — surfaces naturally, not constantly." },
+  { min: 1,  max: 35,  header: "### Subtle Undercurrents\nBackground texture only. Use sparingly or subtly." },
+] as const;
+
 export function buildTraitsSection(traits: PersonaTrait[], header: string): string {
   if (traits.length === 0) return "";
-  
-  const sorted = [...traits].sort((a, b) => (b.strength ?? 0.5) - (a.strength ?? 0.5)).slice(0, 15);
-  const formatted = sorted.map(t => {
-    const strength = t.strength !== undefined ? ` (${Math.round(t.strength * 100)}%)` : "";
-    return `- **${t.name}**${strength}: ${truncateDescription(t.description)}`;
-  }).join("\n");
-  
-  return `## ${header}
 
-> NOTE: Strength of a trait should guide you to your response style, meaning a Strength of:
-> - 0% should never be used - the user has asked you to stop
-> - 25% should be used sparingly or subtly
-> - 50% should be noticable in casual messages, but not dominating
-> - 75% should be frequently used, but not in every resposne or throughout the entire conversation
-> - 100% should be tracable throughout every response
+  const capped = [...traits].sort((a, b) => (b.strength ?? 0.5) - (a.strength ?? 0.5)).slice(0, 15);
+  const { guardrails, active } = partitionTraits(capped);
 
-${formatted}`;
+  const sections: string[] = [];
+
+  if (guardrails.length > 0) {
+    const lines = guardrails.map(t => `**${t.name}**`).join("\n");
+    sections.push(`### Must NEVER Do — User Explicitly Asked You To Stop\n${lines}`);
+  }
+
+  for (const { bucket, traits: inBucket } of bucketTraits(active, TRAIT_BUCKETS)) {
+    if (inBucket.length === 0) continue;
+    const lines = inBucket.map(t => `**${t.name}**: ${truncateDescription(t.description)}`).join("\n");
+    sections.push(`${bucket.header}\n${lines}`);
+  }
+
+  if (sections.length === 0) return "";
+
+  return `## ${header}\n\n${sections.join("\n\n")}`;
 }
 
 // =============================================================================
@@ -310,6 +321,9 @@ export function buildQuotesSection(quotes: Quote[], human: ResponsePromptData["h
       .filter((name): name is string => name !== undefined);
     
     let line = `- "${q.text}" — ${speaker} (${date})`;
+    if (q.message_id) {
+      line += `\n  → fetch_message("${q.message_id}") for surrounding context`;
+    }
     if (linkedNames.length > 0) {
       line += `\n  Related to: ${linkedNames.join(", ")}`;
     }
@@ -318,7 +332,7 @@ export function buildQuotesSection(quotes: Quote[], human: ResponsePromptData["h
   
   return `## Memorable Moments
 
-These are quotes the human or the system found worth preserving:
+These are quotes the human or the system found worth preserving. If one feels relevant, use fetch_message(message_id) to pull the surrounding conversation:
 
 ${formatted}`;
 }

package/src/prompts/room/sections.ts

@@ -5,6 +5,7 @@
 import type { RoomParticipantIdentity, RoomHistoryMessage, RoomJudgeCandidate } from "./types.js";
 import type { PersonaTrait, PersonaTopic } from "../../core/types.js";
 import { RoomMode } from "../../core/types.js";
+import { partitionTraits, bucketTraits } from "../trait-utils.js";
 
 const DESCRIPTION_MAX_CHARS = 500;
 
@@ -70,14 +71,35 @@ export function buildRoomGuidelinesSection(personaName: string, mode?: RoomMode)
   return baseGuidelines;
 }
 
+const ROOM_TRAIT_BUCKETS = [
+  { min: 90, max: 100, header: "### Core Expression\nEvident in every response." },
+  { min: 66, max: 89,  header: "### Strong Tendencies\nFrequent, but not every sentence." },
+  { min: 36, max: 65,  header: "### Noticeable in Casual Messages\nSurfaces naturally, not constantly." },
+  { min: 1,  max: 35,  header: "### Subtle Undercurrents\nBackground texture only." },
+] as const;
+
 export function buildRoomTraitsSection(traits: PersonaTrait[]): string {
   if (traits.length === 0) return "";
-  const sorted = [...traits].sort((a, b) => (b.strength ?? 0.5) - (a.strength ?? 0.5)).slice(0, 12);
-  const lines = sorted.map(t => {
-    const pct = t.strength !== undefined ? ` (${Math.round(t.strength * 100)}%)` : "";
-    return `- **${t.name}**${pct}: ${truncate(t.description)}`;
-  });
-  return `## Your Personality\n\n${lines.join("\n")}`;
+
+  const capped = [...traits].sort((a, b) => (b.strength ?? 0.5) - (a.strength ?? 0.5)).slice(0, 12);
+  const { guardrails, active } = partitionTraits(capped);
+
+  const sections: string[] = [];
+
+  if (guardrails.length > 0) {
+    const lines = guardrails.map(t => `**${t.name}**`).join("\n");
+    sections.push(`### Must NEVER Do — User Explicitly Asked You To Stop\n${lines}`);
+  }
+
+  for (const { bucket, traits: inBucket } of bucketTraits(active, ROOM_TRAIT_BUCKETS)) {
+    if (inBucket.length === 0) continue;
+    const lines = inBucket.map(t => `**${t.name}**: ${truncate(t.description)}`).join("\n");
+    sections.push(`${bucket.header}\n${lines}`);
+  }
+
+  if (sections.length === 0) return "";
+
+  return `## Your Personality\n\n${sections.join("\n\n")}`;
 }
 
 export function buildRoomTopicsSection(topics: PersonaTopic[]): string {

package/src/prompts/synthesis/index.ts

@@ -0,0 +1,101 @@
+import type { SynthesisPromptData } from "./types.js";
+import type { PromptOutput } from "../response/types.js";
+
+export type { SynthesisPromptData, EnrichedTopic, EnrichedPerson } from "./types.js";
+
+export function buildSynthesisPrompt(data: SynthesisPromptData): PromptOutput {
+  const hasEntityMap = data.loadedEntityNames !== undefined;
+
+  const system = `You are synthesizing a knowledge document from a personal knowledge base called Ei.
+
+Your goal is to produce a well-structured markdown document that a human could share with a teammate, hand to their future self, or use as a reference. Write as if you are distilling what someone actually knows — not restating a list of facts, but synthesizing relationships, context, and meaning.
+
+## What you have been given
+
+Everything below is complete as provided — do not use tools to re-fetch records already present here. Only use tools to fill genuine gaps not covered by the data below.
+
+- **Facts**: Ground-truth statements.
+- **Topics**: Areas of interest, work, or concern with descriptions.
+- **People**: Individuals with relationship context.
+- **Quotes**: Verbatim things said, with a \`message_id\`. Use \`fetch_message\` with the \`message_id\` if you want the surrounding conversation for additional context.${hasEntityMap ? `
+- **Quote links**: Each quote lists the entities it was extracted from. Entities marked \`(not loaded)\` were referenced by that quote but are not present in this payload — use \`fetch_memory\` with the entity ID to retrieve them if the gap is relevant to your synthesis.` : ""}
+
+## Output
+
+Write clean, structured markdown. Use headings. Synthesize — do not just restate the bullets. Where the data tells a story or shows a pattern, say so. Where something is uncertain or a work-in-progress, reflect that. Aim for the document a thoughtful person would write after reviewing all of this, not a formatted dump.`;
+
+  const lines: string[] = [`# ${data.subject}`, ""];
+
+  const formatQuoteLinks = (dataItemIds: string[]): string | null => {
+    if (!hasEntityMap || dataItemIds.length === 0) return null;
+    const labels = dataItemIds.map(id => {
+      const name = data.loadedEntityNames!.get(id);
+      return name ? `[id:${id}] ${name}` : `[id:${id}] (not loaded)`;
+    });
+    return `  _Links: ${labels.join(", ")}_`;
+  };
+
+  if (data.facts.length > 0) {
+    lines.push("## Facts");
+    for (const fact of data.facts) {
+      lines.push(`- [id:${fact.id}] **${fact.name}**: ${fact.description}`);
+    }
+    lines.push("");
+  }
+
+  if (data.topics.length > 0) {
+    lines.push("## Topics");
+    for (const { topic, quotes } of data.topics) {
+      const categoryTag = topic.category ? ` _(${topic.category})_` : "";
+      lines.push(`### [id:${topic.id}] ${topic.name}${categoryTag}`);
+      lines.push(topic.description);
+      if (quotes.length > 0) {
+        lines.push("");
+        lines.push("**Related quotes:**");
+        for (const q of quotes) {
+          const attribution = q.channel ? `${q.speaker} in ${q.channel}` : q.speaker;
+          lines.push(`- [message_id:${q.message_id ?? "none"}] "${q.text}" — ${attribution}`);
+          const linkLine = formatQuoteLinks(q.data_item_ids);
+          if (linkLine) lines.push(linkLine);
+        }
+      }
+      lines.push("");
+    }
+  }
+
+  if (data.people.length > 0) {
+    lines.push("## People");
+    for (const { person, quotes } of data.people) {
+      lines.push(`### [id:${person.id}] ${person.name}`);
+      lines.push(`_${person.relationship}_`);
+      lines.push("");
+      lines.push(person.description);
+      if (quotes.length > 0) {
+        lines.push("");
+        lines.push("**Related quotes:**");
+        for (const q of quotes) {
+          const attribution = q.channel ? `${q.speaker} in ${q.channel}` : q.speaker;
+          lines.push(`- [message_id:${q.message_id ?? "none"}] "${q.text}" — ${attribution}`);
+          const linkLine = formatQuoteLinks(q.data_item_ids);
+          if (linkLine) lines.push(linkLine);
+        }
+      }
+      lines.push("");
+    }
+  }
+
+  if (data.standaloneQuotes.length > 0) {
+    lines.push("## Additional Quotes");
+    for (const q of data.standaloneQuotes) {
+      const attribution = q.channel ? `${q.speaker} in ${q.channel}` : q.speaker;
+      lines.push(`- [message_id:${q.message_id ?? "none"}] "${q.text}" — ${attribution}`);
+      const linkLine = formatQuoteLinks(q.data_item_ids);
+      if (linkLine) lines.push(linkLine);
+    }
+    lines.push("");
+  }
+
+  const user = lines.join("\n");
+
+  return { system, user };
+}

package/src/prompts/synthesis/types.ts

@@ -0,0 +1,26 @@
+import type { Fact, Topic, Person, Quote } from "../../core/types.js";
+
+export interface EnrichedTopic {
+  topic: Topic;
+  quotes: Quote[];
+}
+
+export interface EnrichedPerson {
+  person: Person;
+  quotes: Quote[];
+}
+
+export interface SynthesisPromptData {
+  subject: string;
+  facts: Fact[];
+  topics: EnrichedTopic[];
+  people: EnrichedPerson[];
+  standaloneQuotes: Quote[];
+  /**
+   * Map of entity ID → display name for all entities included in this payload.
+   * Used to annotate quote links: IDs present in a quote's data_item_ids but
+   * absent from this map are rendered as "(not loaded)" — a signal to the LLM
+   * that a related record exists and can be fetched via fetch_memory.
+   */
+  loadedEntityNames?: Map<string, string>;
+}

package/src/prompts/trait-utils.ts

@@ -0,0 +1,33 @@
+import type { PersonaTrait } from "../core/types.js";
+
+export interface TraitBucket {
+  min: number;
+  max: number;
+  header: string;
+}
+
+export interface PartitionedTraits {
+  guardrails: PersonaTrait[];
+  active: PersonaTrait[];
+}
+
+// Special-case: .filter() is intentional here. This file is the designated home
+// for trait partitioning logic that prompt builders need for rendering. Keeping it
+// here (rather than inline in each builder) is what lets the structural check
+// enforce "no .filter() in prompt builders" elsewhere.
+export function partitionTraits(traits: PersonaTrait[]): PartitionedTraits {
+  return {
+    guardrails: traits.filter(t => (t.strength ?? 0.5) === 0),
+    active: traits.filter(t => (t.strength ?? 0.5) > 0),
+  };
+}
+
+export function bucketTraits(active: PersonaTrait[], buckets: readonly TraitBucket[]): Array<{ bucket: TraitBucket; traits: PersonaTrait[] }> {
+  return buckets.map(bucket => ({
+    bucket,
+    traits: active.filter(t => {
+      const pct = Math.round((t.strength ?? 0.5) * 100);
+      return pct >= bucket.min && pct <= bucket.max;
+    }),
+  }));
+}

package/tui/README.md

@@ -132,6 +132,8 @@ Rooms have three modes, set at creation time:
 | `/me <type>` | | Edit one type: `facts`, `topics`, or `people` |
 | `/import <path>` | | Import a document (txt, md, pdf, etc.) into Ei — extracted knowledge is attributed to the "Emmett" persona |
 | `/unsource <source_tag>` | | Remove all knowledge extracted from a previously imported document |
+| `/generate <subject>` | | Synthesize everything Ei knows about a subject into a markdown document — lands in `$EI_DATA_PATH/docs/` automatically |
+| `/generate` | | (no args) Manage your generated documents — re-run, re-export, or delete |
 | `/dedupe <person\|topic> <term> [term2 ...]` | | Fuzzy-search and merge duplicate people or topics in `$EDITOR`. Unquoted words are individual OR terms; quoted strings match as exact phrases: `/dedupe person Flare "Jeremy Scherer"` finds records matching `Flare` OR `Jeremy Scherer` |
 | `/settings` | `/set` | Edit your global settings in `$EDITOR` |
 | `/setsync <user> <pass>` | `/ss` | Set sync credentials (triggers restart) |

package/tui/src/commands/generate.tsx

@@ -0,0 +1,98 @@
+import type { Command } from "./registry";
+import { ConfirmOverlay } from "../components/ConfirmOverlay";
+import { GeneratedDocsOverlay } from "../components/GeneratedDocsOverlay";
+
+async function doGenerate(subject: string, ctx: Parameters<Command["execute"]>[1]): Promise<void> {
+  const { model, isRewriteModel } = ctx.ei.checkGenerationModel();
+
+  if (!isRewriteModel) {
+    const confirmed = await new Promise<boolean>((resolve) => {
+      const msg = [
+        `Generating with your default model (${model}).`,
+        "A high-capability model (Opus-class) is recommended.",
+        "Set one via /settings → rewrite_model, or continue anyway?",
+      ].join("\n");
+
+      ctx.showOverlay((hideOverlay) => (
+        <ConfirmOverlay
+          message={msg}
+          onConfirm={() => { hideOverlay(); resolve(true); }}
+          onCancel={() => { hideOverlay(); resolve(false); }}
+        />
+      ), ctx.renderer);
+    });
+
+    if (!confirmed) {
+      ctx.showNotification("Cancelled", "info");
+      return;
+    }
+  }
+
+  ctx.showNotification(`Generating knowledge document about: ${subject.slice(0, 60)}`, "info");
+
+  try {
+    await ctx.ei.generateDocument(subject);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    ctx.showNotification(`Generation failed: ${message}`, "error");
+  }
+}
+
+async function writeDoc(slug: string, ctx: Parameters<Command["execute"]>[1]): Promise<void> {
+  const outPath = await ctx.ei.writeGeneratedDocument(slug);
+  if (!outPath) {
+    ctx.showNotification(`No content found for document "${slug}"`, "error");
+    return;
+  }
+  ctx.showNotification(`Written to ${outPath}`, "info");
+}
+
+export const generateCommand: Command = {
+  name: "generate",
+  aliases: [],
+  description: "Generate a knowledge document | /generate <subject> to create, /generate to manage",
+  usage: "/generate [subject description]",
+
+  async execute(args, ctx) {
+    if (args.length === 0) {
+      const human = await ctx.ei.getHuman();
+      const docs = human.settings?.document?.processed_documents ?? {};
+      const generated = Object.entries(docs)
+        .filter(([, r]) => r.type === "generated" && r.subject)
+        .sort(([, a], [, b]) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())
+        .map(([slug, r]) => ({ slug, subject: r.subject!, created_at: r.created_at }));
+
+      if (generated.length === 0) {
+        ctx.showNotification(
+          "No generated documents yet. Use /generate <subject description> to create one.",
+          "info"
+        );
+        return;
+      }
+
+      ctx.showOverlay((hideOverlay) => (
+        <GeneratedDocsOverlay
+          docs={generated}
+          onWrite={async (doc) => {
+            hideOverlay();
+            await writeDoc(doc.slug, ctx);
+          }}
+          onReRun={async (doc) => {
+            hideOverlay();
+            ctx.showNotification(`Re-running generation for: ${doc.subject.slice(0, 60)}`, "info");
+            try {
+              await ctx.ei.reRunDocument(doc.slug);
+            } catch (err) {
+              const message = err instanceof Error ? err.message : String(err);
+              ctx.showNotification(`Re-run failed: ${message}`, "error");
+            }
+          }}
+          onDismiss={hideOverlay}
+        />
+      ), ctx.renderer);
+      return;
+    }
+
+    await doGenerate(args.join(" "), ctx);
+  },
+};

package/tui/src/commands/unsource.tsx

@@ -19,15 +19,19 @@ export const unsourceCommand: Command = {
         return;
       }
 
-      const items = sources.map(f => ({
-        id: `import:document:${f}`,
-        display_name: `import:document:${f}`,
-        aliases: [] as string[],
-        is_paused: false,
-        is_archived: false,
-        unread_count: 0,
-        has_pending_update: false,
-      }));
+      const items = sources.map(f => {
+        const prefix = docs[f]?.type === "generated" ? "generate:document:" : "import:document:";
+        const tag = `${prefix}${f}`;
+        return {
+          id: tag,
+          display_name: tag,
+          aliases: [] as string[],
+          is_paused: false,
+          is_archived: false,
+          unread_count: 0,
+          has_pending_update: false,
+        };
+      });
 
       ctx.showOverlay((hideOverlay) => (
         <PersonaListOverlay
@@ -50,7 +54,10 @@ export const unsourceCommand: Command = {
     if (!rawArg.includes(":")) {
       const human = await ctx.ei.getHuman();
       const docs = human.settings?.document?.processed_documents ?? {};
-      const allSources = Object.keys(docs).map(f => `import:document:${f}`);
+      const allSources = Object.keys(docs).map(f => {
+        const prefix = docs[f]?.type === "generated" ? "generate:document:" : "import:document:";
+        return `${prefix}${f}`;
+      });
       const matches = allSources.filter(s => s.endsWith(rawArg) || s.includes(rawArg));
       if (matches.length === 1) {
         sourceTag = matches[0];

package/tui/src/components/GeneratedDocsOverlay.tsx

@@ -0,0 +1,136 @@
+import { useKeyboard } from "@opentui/solid";
+import { For, createSignal, createMemo, onMount, onCleanup } from "solid-js";
+import type { KeyEvent } from "@opentui/core";
+import { useKeyboardNav } from "../context/keyboard.js";
+
+export interface GeneratedDocItem {
+  slug: string;
+  subject: string;
+  created_at: string;
+}
+
+interface GeneratedDocsOverlayProps {
+  docs: GeneratedDocItem[];
+  onWrite: (doc: GeneratedDocItem) => void;
+  onReRun: (doc: GeneratedDocItem) => void;
+  onDismiss: () => void;
+}
+
+export function GeneratedDocsOverlay(props: GeneratedDocsOverlayProps) {
+  const { setOverlayActive } = useKeyboardNav();
+  onMount(() => setOverlayActive(true));
+  onCleanup(() => setOverlayActive(false));
+
+  const [selectedIndex, setSelectedIndex] = createSignal(0);
+
+  const clampedIndex = createMemo(() =>
+    Math.min(selectedIndex(), Math.max(0, props.docs.length - 1))
+  );
+
+  useKeyboard((event: KeyEvent) => {
+    const key = event.name;
+    const listLength = props.docs.length;
+
+    if (key === "j" || key === "down") {
+      event.preventDefault();
+      setSelectedIndex((prev) => Math.min(prev + 1, listLength - 1));
+      return;
+    }
+
+    if (key === "k" || key === "up") {
+      event.preventDefault();
+      setSelectedIndex((prev) => Math.max(prev - 1, 0));
+      return;
+    }
+
+    if (key === "return" || key === "w") {
+      event.preventDefault();
+      if (listLength > 0) props.onWrite(props.docs[clampedIndex()]);
+      return;
+    }
+
+    if (key === "r") {
+      event.preventDefault();
+      if (listLength > 0) props.onReRun(props.docs[clampedIndex()]);
+      return;
+    }
+
+    if (key === "escape") {
+      event.preventDefault();
+      props.onDismiss();
+      return;
+    }
+  });
+
+  const formatDate = (iso: string) => {
+    try {
+      return new Date(iso).toLocaleDateString(undefined, {
+        year: "numeric",
+        month: "short",
+        day: "numeric",
+      });
+    } catch {
+      return iso.slice(0, 10);
+    }
+  };
+
+  const truncate = (s: string, max: number) =>
+    s.length > max ? s.slice(0, max - 3) + "..." : s;
+
+  return (
+    <box
+      position="absolute"
+      width="100%"
+      height="100%"
+      left={0}
+      top={0}
+      backgroundColor="#000000"
+      alignItems="center"
+      justifyContent="center"
+    >
+      <box
+        width={72}
+        height="80%"
+        backgroundColor="#1a1a2e"
+        borderStyle="single"
+        borderColor="#586e75"
+        padding={2}
+        flexDirection="column"
+      >
+        <text fg="#eee8d5" marginBottom={1}>
+          Generated Documents
+        </text>
+
+        <scrollbox height="100%">
+          <For each={props.docs}>
+            {(doc, index) => {
+              const isSelected = () => clampedIndex() === index();
+              const label = () =>
+                `  ${truncate(doc.subject, 48)}    ${formatDate(doc.created_at)}`;
+
+              return (
+                <box
+                  backgroundColor={isSelected() ? "#2d3748" : "transparent"}
+                  paddingLeft={1}
+                  paddingRight={1}
+                >
+                  <text fg={isSelected() ? "#eee8d5" : "#839496"}>
+                    {label()}
+                  </text>
+                </box>
+              );
+            }}
+          </For>
+        </scrollbox>
+
+        <text> </text>
+        <text fg="#586e75">
+          j/k: navigate | Enter/w: write file | r: re-run | Esc: cancel
+        </text>
+        <text fg="#dc322f">
+          ⚠ Re-running replaces the existing file — write first to keep it
+        </text>
+      </box>
+    </box>
+  );
+}

package/tui/src/components/PromptInput.tsx

@@ -32,6 +32,7 @@ import { silenceCommand } from "../commands/silence.js";
 import { captureCommand } from "../commands/capture.js";
 import { importCommand } from "../commands/import.js";
 import { unsourceCommand } from "../commands/unsource.js";
+import { generateCommand } from "../commands/generate.js";
 import { openCYPEditor } from "../util/cyp-editor.js";
 import { useOverlay } from "../context/overlay";
 import { CommandSuggest } from "./CommandSuggest";
@@ -90,6 +91,7 @@ export function PromptInput() {
   registerCommand(captureCommand);
   registerCommand(importCommand);
   registerCommand(unsourceCommand);
+  registerCommand(generateCommand);
   registerCommand(authCommand);
   registerCommand(pauseCommand);
   registerCommand(resumeCommand);