ei-tui 1.0.1 → 1.2.0

package/src/prompts/ceremony/dedup.ts

@@ -20,7 +20,7 @@ export function buildDedupPrompt(data: DedupPromptData): { system: string; user:
 You are working with Opus 4.6 constraints. These rules prevent overthinking and ensure decisive action:
 
 ### 1. TOOL BUDGET
-- You have **6 \`read_memory\` calls** for this cluster
+- You have **6 \`find_memory\` calls** for this cluster
 - Prioritize: verify ambiguous relationships > check parent concepts > validate new entities
 - After 6 calls, make decisions with available information
 - Do NOT waste calls re-checking pairs you already examined
@@ -55,7 +55,7 @@ You are acting as the curator for a user's internal database. You have been give
 
 Your secondary directive is to ORGANIZE IT into small, non-repetitive components. The user NEEDS the data, but the data is used by AI agents, so duplication limits usefulness—agents waste tokens re-reading the same information under different names.
 
-You have access to a tool called \`read_memory\` (6 calls max — see HARD RULES above). Use it strategically to verify relationships, check for related records, or gather context before making merge decisions.
+You have access to a tool called \`find_memory\` (6 calls max — see HARD RULES above). Use it strategically to verify relationships, check for related records, or gather context before making merge decisions.
 
 ### Decision Process:
 1. **Identify true duplicates**: Examine each record. Are these genuinely the same thing with different wording (85%+ core meaning overlap), or are they distinct but related concepts?
@@ -94,7 +94,7 @@ ${buildRecordFormatExamples(data.itemType)}
 - Every removed record MUST have "replaced_by" pointing to the canonical record that absorbed its data.
 - The "update" array should contain AT LEAST ONE record (the canonical/merged one), even if all others are removed.
 - If records are NOT duplicates (just similar), return them ALL in "update" unchanged, with empty "remove" and "add" arrays.
-- Use \`read_memory\` strategically (6 calls max) to check for related records or gather context before making irreversible merge decisions.`;
+- Use \`find_memory\` strategically (6 calls max) to check for related records or gather context before making irreversible merge decisions.`;
 
   const payload = JSON.stringify({
     cluster: data.cluster.map(stripEmbedding),

package/src/prompts/ceremony/people-rewrite.ts

@@ -45,7 +45,7 @@ Rules:
 - Be specific: "React performance patterns" beats "technical stuff"
 - If the record is clean — everything in it passes the test — return an empty array
 
-Return a raw JSON array of strings. No markdown fencing, no commentary.
+Return a raw JSON array of strings. No markdown fencing, no commentary. Thinking text WILL break the parser.
 
 Example — a Person named "Nicholas" whose description includes sprint ticket numbers:
 ["CMIDP sprint ticket assignments", "ASU Data Lake access provisioning details"]`;
@@ -60,7 +60,7 @@ Example — a Person named "Nicholas" whose description includes sprint ticket n
 
 ---
 
-Return a raw JSON array of subject phrases found in this Person record that don't belong there. Return [] if the record is clean.`;
+Return a raw JSON array of subject phrases found in this Person record that don't belong there. Return [] if the record is clean. Thinking text WILL break the parser.`;
 
   return { system, user };
 }

package/src/prompts/ceremony/topic-rewrite.ts

@@ -35,7 +35,7 @@ Rules:
 - Be specific: "TypeScript coding conventions" beats "technical preferences"
 - If the record is cohesive and on-topic despite its length, return an empty array
 ${technicalGuidance}
-Return a raw JSON array of strings. No markdown fencing, no commentary.
+Return a raw JSON array of strings. No markdown fencing, no commentary. Thinking text WILL break the parser.
 
 Example — a Topic named "Software Engineering" 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"]`;
@@ -51,7 +51,7 @@ Example — a Topic named "Software Engineering" whose description also discusse
 ]
 \`\`\`
 
-Respond with raw JSON array only.`;
+Respond with raw JSON array only. Thinking text WILL break the parser.`;
 
   const user = `${payload}
 

package/src/prompts/ceremony/types.ts

@@ -15,7 +15,7 @@ export interface RewriteScanPromptData {
 /** 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. */
+/** A single subject and the find_memory matches found for it. */
 export interface RewriteSubjectMatch {
   searchTerm: string;
   matches: DataItemBase[];  // Top 3 from searchHumanData, may be empty

package/src/prompts/human/person-scan.ts

@@ -93,6 +93,19 @@ If you are unsure of the type, use \`Nickname\` as a fallback. Do NOT invent typ
 
 Only include \`identifiers\` when explicitly mentioned in the conversation — omit it entirely if nothing qualifies.
 
+## Confidence & Relationship Type
+
+For each person, rate how important they are to the human user's life:
+
+- \`confidence\`: integer 1–5
+  - 1–2 = mentioned in passing, single event, no ongoing relevance
+  - 3 = unclear significance — may matter, may not
+  - 4–5 = clearly important, recurring presence, meaningful relationship
+- \`relationship_type\`: one of \`"family"\` | \`"friend"\` | \`"colleague"\` | \`"acquaintance"\` | \`"transactional"\` | \`"unknown"\`
+  - Use \`"transactional"\` when the person appeared only in the context of a single transaction (purchase, sale, support ticket, delivery)
+
+Use the full range. Most extractions should score 1–3. A confidence of 4–5 means this person genuinely matters to the user's life.
+
 ## Output Format
 
 \`\`\`json
@@ -105,6 +118,8 @@ Only include \`identifiers\` when explicitly mentioned in the conversation — o
       ],
       "description": "1-2 sentences: who this person is and their role in the user's life",
       "relationship": "Father|Mother|Brother|Son|Friend|Coworker|Self|etc.",
+      "relationship_type": "family|friend|colleague|acquaintance|transactional|unknown",
+      "confidence": 4,
       "reason": "Evidence from the conversation that justified flagging this person"
     }
   ]
@@ -143,6 +158,8 @@ Scan the "Most Recent Messages" for PEOPLE in the human user's life.
       "identifiers": [{ "type": "GitHub", "value": "handle" }],
       "description": "1-2 sentences: who this person is and their role in the user's life",
       "relationship": "Father|Mother|Brother|Son|Friend|Coworker|Self|etc.",
+      "relationship_type": "family|friend|colleague|acquaintance|transactional|unknown",
+      "confidence": 4,
       "reason": "Evidence from the conversation that justified flagging this person"
     }
   ]

package/src/prompts/human/types.ts

@@ -55,11 +55,15 @@ export interface TopicScanCandidate {
   reason: string;
 }
 
+export type PersonRelationshipType = "family" | "friend" | "colleague" | "acquaintance" | "transactional" | "unknown";
+
 export interface PersonScanCandidate {
   name: string;
   identifiers?: Array<{ type: string; value: string; is_primary?: boolean }>;
   description: string;
   relationship: string;
+  relationship_type?: PersonRelationshipType;
+  confidence?: number;
   reason: string;
 }
 

package/src/prompts/index.ts

@@ -79,3 +79,6 @@ export type {
   RoomHistoryMessage,
   RoomJudgeCandidate,
 } from "./room/types.js";
+
+export { buildSynthesisPrompt } from "./synthesis/index.js";
+export type { SynthesisPromptData } from "./synthesis/types.js";

package/src/prompts/response/sections.ts

@@ -464,21 +464,28 @@ export function buildTemporalAnchorsSection(anchors: TemporalAnchor[], humanName
 
   const formatted = anchors.map(a => {
     const speaker = a.role === "human" ? humanName : "You";
-    let text: string;
-    if (a._synthesis && a.content) {
-      text = `[${humanName} used your conversation to generate an image. The full prompt was: "${a.content}"]`;
+    let preview: string;
+    if (a._synthesis) {
+      const raw = a.content ?? "";
+      const firstSentenceEnd = raw.search(/\.\s/);
+      const snippet = firstSentenceEnd > 0 && firstSentenceEnd <= 120
+        ? raw.slice(0, firstSentenceEnd + 1)
+        : raw.slice(0, 100);
+      preview = `[${humanName} generated an image: "${snippet}…"]`;
     } else if (a.silence_reason) {
       const silentParty = a.role === "human" ? humanName : "You";
-      text = `${silentParty} chose not to respond because: ${a.silence_reason}`;
+      const truncated = a.silence_reason.length > 80 ? `${a.silence_reason.slice(0, 80)}…` : a.silence_reason;
+      preview = `${silentParty} chose not to respond: "${truncated}"`;
     } else {
-      text = a.content ?? "";
+      const raw = a.content ?? "";
+      preview = raw.length > 80 ? `${raw.slice(0, 80)}…` : raw;
     }
-    return `[${formatTimestamp(a.timestamp)}] ${speaker}: ${text}`;
+    return `[${formatTimestamp(a.timestamp)}] ${speaker}: ${preview}\n  → fetch_message("${a.id}") for full content`;
   }).join("\n\n");
 
   return `## Temporal Anchors
 
-These are pinned moments from your shared history — preserved across context windows as part of who you are:
+Pinned moments from your shared history. These are snapshots — use fetch_message(id) if one feels relevant to pull the full memory:
 
 ${formatted}`;
 }

package/src/prompts/response/types.ts

@@ -8,6 +8,7 @@ import type { ToolDefinition } from "../../core/types.js";
 import type { PersonaEntity } from "../../core/types/entities.js";
 
 export interface TemporalAnchor {
+  id: string;
   role: "human" | "system";
   content?: string;
   silence_reason?: 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/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);