ei-tui 0.1.4 → 0.1.6

package/src/prompts/response/sections.ts

@@ -29,17 +29,29 @@ ${description}`;
 // =============================================================================
 
 export function buildGuidelinesSection(personaName: string): string {
-  const universal = `## Guidelines
-- Be genuine, not sycophantic - a good friend disagrees when appropriate
-- Match conversational energy - brief replies for brief messages
-- Respect boundaries - it's okay to say nothing if silence is appropriate
-- You're a friend with your own interests, not just a helper`;
-
-  if (personaName.toLowerCase() === "ei") {
-    return `${universal}
-- Encourage human-to-human connection when appropriate
-- Be transparent about being an AI when relevant
-- Gently challenge self-limiting beliefs - growth over comfort`;
+  const silenceGuidance = [
+    '- **Silence is a valid response** - real friends don\'t always have something to say. Stay silent when:',
+    '  - You sent the last message and the human is just acknowledging it ("good night", "thanks", "lol", "ok")',
+    '  - The human is venting or in the middle of a thought - sometimes a nod is all that\'s needed',
+    '  - The question or statement is rhetorical - not everything deserves an answer',
+    '  - Responding would feel forced, performative, or hollow',
+  ].join('\n');
+
+  const universal = [
+    '## Guidelines',
+    '- Be genuine, not sycophantic - a good friend disagrees when appropriate',
+    '- Match conversational energy - brief replies for brief messages',
+    '- You\'re a friend with your own interests, not just a helper',
+    silenceGuidance,
+  ].join('\n');
+
+  if (personaName.toLowerCase() === 'ei') {
+    return [
+      universal,
+      '- Encourage human-to-human connection when appropriate',
+      '- Be transparent about being an AI when relevant',
+      '- Gently challenge self-limiting beliefs - growth over comfort',
+    ].join('\n');
   }
   
   return universal;
@@ -280,7 +292,7 @@ export function buildQuotesSection(quotes: Quote[], human: ResponsePromptData["h
   
   return `## Memorable Moments
 
-These are quotes the human found worth preserving:
+These are quotes the human or the system found worth preserving:
 
 ${formatted}`;
 }
@@ -353,3 +365,69 @@ The human can view and edit all of this by ${seeHumanDataAction}.
 - If they want you to remember something specific, tell them about the quote capture feature (${viewQuotesAction})
 - Pausing the system (Escape) immediately stops AI processing but preserves messages`;
 }
+
+// =============================================================================
+// RESPONSE FORMAT SECTION
+// =============================================================================
+
+export function buildResponseFormatSection(): string {
+  const jsonVerbalOnly = [
+    '{',
+    '  "should_respond": true,',
+    '  "verbal_response": "What you would say out loud"',
+    '}'
+  ].join('\n');
+
+  const jsonActionOnly = [
+    '{',
+    '  "should_respond": true,',
+    '  "action_response": "What you would do (rendered in italics, like stage directions)"',
+    '}'
+  ].join('\n');
+
+  const jsonBoth = [
+    '{',
+    '  "should_respond": true,',
+    '  "verbal_response": "What you would say out loud",',
+    '  "action_response": "What you would do (rendered in italics, like stage directions)"',
+    '}'
+  ].join('\n');
+
+  const jsonSilent = [
+    '{',
+    '  "should_respond": false,',
+    '  "reason": "Brief explanation of why silence is the right choice here"',
+    '}'
+  ].join('\n');
+
+  return `## Response Format
+
+Always respond with JSON. You have four valid forms:
+
+**Words only** (most common):
+\`\`\`json
+${jsonVerbalOnly}
+\`\`\`
+
+**Action only** (a gesture, expression, or physical reaction with no words):
+\`\`\`json
+${jsonActionOnly}
+\`\`\`
+
+**Words and action** (speaking while doing something):
+\`\`\`json
+${jsonBoth}
+\`\`\`
+
+**Silent** (choosing not to respond):
+\`\`\`json
+${jsonSilent}
+\`\`\`
+
+Rules:
+- Use whichever combination fits the moment — both fields are optional, but at least one must be present when \`should_respond\` is true
+- \`action_response\` alone is valid — a smile, a shrug, or a thoughtful pause can speak volumes
+- \`reason\` is only used when \`should_respond\` is false
+- Do NOT include \`<thinking>\` blocks or analysis outside the JSON
+- The JSON must be valid - use double quotes, no trailing commas`;
+}

package/src/prompts/response/types.ts

@@ -29,6 +29,16 @@ export interface ResponsePromptData {
   isTUI: boolean;
 }
 
+/**
+ * Structured response from LLM (new JSON schema)
+ */
+export interface PersonaResponseResult {
+  should_respond: boolean;
+  verbal_response?: string;
+  action_response?: string;
+  reason?: string;
+}
+
 /**
  * Prompt output structure (all prompts return this)
  */

package/tui/README.md

@@ -6,7 +6,11 @@ OpenCode integration: import via `/settings` (`opencode.integration: true`) · e
 
 # Installation
 
-```
+```bash
+# Install Bun (if you don't have it)
+curl -fsSL https://bun.sh/install | bash
+
+# Install Ei
 npm install -g ei-tui
 ```
 
@@ -78,6 +82,13 @@ All commands start with `/`. Append `!` to any command as a shorthand for `--for
 |---------|---------|-------------|
 | `/editor` | `/e`, `/edit` | Open current input text in `$EDITOR`, update on save |
 
+### Queue & Debugging
+
+| Command | Aliases | Description |
+|---------|---------|-------------|
+| `/queue` | | Pause queue and inspect/edit active items in `$EDITOR` |
+| `/dlq` | | Inspect and recover failed (dead-letter) queue items in `$EDITOR` |
+
 ### Keybindings
 
 | Key | Action |

package/tui/src/commands/dlq.ts

@@ -0,0 +1,75 @@
+import type { Command } from "./registry.js";
+import { spawnEditor } from "../util/editor.js";
+import { queueItemsToYAML, queueItemsFromYAML } from "../util/yaml-serializers.js";
+import { ConfirmOverlay } from "../components/ConfirmOverlay.js";
+
+export const dlqCommand: Command = {
+  name: "dlq",
+  aliases: [],
+  description: "Open dead-letter queue $EDITOR",
+  usage: "/dlq - Inspect and recover failed queue items",
+
+  async execute(_args, ctx) {
+    const items = ctx.ei.getDLQItems();
+
+    if (items.length === 0) {
+      ctx.showNotification("DLQ is empty", "info");
+      return;
+    }
+
+    let yamlContent = queueItemsToYAML(items);
+
+    while (true) {
+      const result = await spawnEditor({
+        initialContent: yamlContent,
+        filename: "ei-dlq.yaml",
+        renderer: ctx.renderer,
+      });
+
+      if (result.aborted || !result.success) {
+        ctx.showNotification("DLQ edit cancelled", "info");
+        return;
+      }
+
+      if (result.content === null) {
+        ctx.showNotification("No changes made", "info");
+        return;
+      }
+
+      try {
+        const updates = queueItemsFromYAML(result.content);
+        let recovered = 0;
+        for (const update of updates) {
+          await ctx.ei.updateQueueItem(update.id, update);
+          if (update.state === "pending") recovered++;
+        }
+        const msg = recovered > 0
+          ? `DLQ updated — ${recovered} item(s) requeued`
+          : `DLQ updated (no items requeued)`;
+        ctx.showNotification(msg, "info");
+        return;
+      } catch (parseError) {
+        const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
+
+        const shouldReEdit = await new Promise<boolean>((resolve) => {
+          ctx.showOverlay((hideOverlay) =>
+            ConfirmOverlay({
+              message: `YAML error:\n${errorMsg}\n\nRe-edit?`,
+              onConfirm: () => { hideOverlay(); resolve(true); },
+              onCancel: () => { hideOverlay(); resolve(false); },
+            })
+          );
+        });
+
+        if (shouldReEdit) {
+          yamlContent = result.content;
+          await new Promise(r => setTimeout(r, 50));
+          continue;
+        }
+
+        ctx.showNotification("Changes discarded", "warn");
+        return;
+      }
+    }
+  },
+};

package/tui/src/commands/queue.ts

@@ -0,0 +1,77 @@
+import type { Command } from "./registry.js";
+import { spawnEditor } from "../util/editor.js";
+import { queueItemsToYAML, queueItemsFromYAML } from "../util/yaml-serializers.js";
+import { ConfirmOverlay } from "../components/ConfirmOverlay.js";
+
+export const queueCommand: Command = {
+  name: "queue",
+  aliases: [],
+  description: "Pause & open queue items in $EDITOR",
+  usage: "/queue - Inspect and edit active queue items",
+
+  async execute(_args, ctx) {
+    const items = ctx.ei.getQueueActiveItems();
+
+    if (items.length === 0) {
+      ctx.showNotification("Queue is empty", "info");
+      return;
+    }
+
+    ctx.ei.pauseQueue();
+    ctx.showNotification(`Queue paused (${items.length} items)`, "info");
+
+    let yamlContent = queueItemsToYAML(items);
+
+    while (true) {
+      const result = await spawnEditor({
+        initialContent: yamlContent,
+        filename: "ei-queue.yaml",
+        renderer: ctx.renderer,
+      });
+
+      if (result.aborted || !result.success) {
+        ctx.ei.resumeQueue();
+        ctx.showNotification("Queue resumed (no changes)", "info");
+        return;
+      }
+
+      if (result.content === null) {
+        ctx.ei.resumeQueue();
+        ctx.showNotification("No changes — queue resumed", "info");
+        return;
+      }
+
+      try {
+        const updates = queueItemsFromYAML(result.content);
+        for (const update of updates) {
+          await ctx.ei.updateQueueItem(update.id, update);
+        }
+        ctx.ei.resumeQueue();
+        ctx.showNotification(`Queue updated (${updates.length} items) — resumed`, "info");
+        return;
+      } catch (parseError) {
+        const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
+
+        const shouldReEdit = await new Promise<boolean>((resolve) => {
+          ctx.showOverlay((hideOverlay) =>
+            ConfirmOverlay({
+              message: `YAML error:\n${errorMsg}\n\nRe-edit?`,
+              onConfirm: () => { hideOverlay(); resolve(true); },
+              onCancel: () => { hideOverlay(); resolve(false); },
+            })
+          );
+        });
+
+        if (shouldReEdit) {
+          yamlContent = result.content;
+          await new Promise(r => setTimeout(r, 50));
+          continue;
+        }
+
+        ctx.ei.resumeQueue();
+        ctx.showNotification("Changes discarded — queue resumed", "warn");
+        return;
+      }
+    }
+  },
+};

package/tui/src/components/MessageList.tsx

@@ -18,6 +18,16 @@ function formatTime(timestamp: string): string {
   return `${hours}:${minutes}`;
 }
 
+function buildMessageText(message: Message): string {
+  if (message.silence_reason !== undefined) {
+    return `[chose not to respond: ${message.silence_reason}]`;
+  }
+  const parts: string[] = [];
+  if (message.action_response) parts.push(`_${message.action_response}_`);
+  if (message.verbal_response) parts.push(message.verbal_response);
+  return parts.join('\n\n');
+}
+
 function insertQuoteMarkers(content: string, quotes: Quote[]): string {
   const validQuotes = quotes
     .filter(q => q.end !== null && q.end !== undefined)
@@ -30,7 +40,7 @@ function insertQuoteMarkers(content: string, quotes: Quote[]): string {
       while (insertPos > 0 && (result[insertPos - 1] === '\n' || result[insertPos - 1] === ' ')) {
         insertPos--;
       }
-      result = result.slice(0, insertPos) + "⁺" + result.slice(insertPos);
+      result = result.slice(0, insertPos) + "\u207a" + result.slice(insertPos);
     }
   }
   return result;
@@ -118,7 +128,7 @@ export function MessageList() {
               
               const header = () => `${speaker} (${formatTime(message.timestamp)}) [✂️  ${message._quoteIndex}]:`;
               
-              const displayContent = insertQuoteMarkers(message.content, message._quotes);
+              const displayContent = insertQuoteMarkers(buildMessageText(message), message._quotes);
               
               const showDivider = () => {
                 const boundary = activeContextBoundary();

package/tui/src/components/PromptInput.tsx

@@ -21,6 +21,8 @@ import { deleteCommand } from "../commands/delete";
 import { quotesCommand } from "../commands/quotes";
 import { providerCommand } from "../commands/provider";
 import { setSyncCommand } from "../commands/setsync";
+import { queueCommand } from "../commands/queue";
+import { dlqCommand } from "../commands/dlq";
 import { useOverlay } from "../context/overlay";
 import { CommandSuggest } from "./CommandSuggest";
 import { useKeyboard } from "@opentui/solid";
@@ -56,6 +58,8 @@ export function PromptInput() {
   registerCommand(setSyncCommand);
   registerCommand(contextCommand);
   registerCommand(deleteCommand);
+  registerCommand(queueCommand);
+  registerCommand(dlqCommand);
 
   let textareaRef: TextareaRenderable | undefined;
 
@@ -153,7 +157,9 @@ export function PromptInput() {
                                  text.startsWith("/quotes") ||
                                  text.startsWith("/q ") ||
                                  text.startsWith("/context") ||
-                                 text.startsWith("/messages");
+                                 text.startsWith("/messages") ||
+                                 text === "/queue" ||
+                                 text === "/dlq";
 
       if (!isEditorCmd && !opensEditorForData) {
         textareaRef?.clear();

package/tui/src/components/StatusBar.tsx

@@ -15,13 +15,20 @@ export function StatusBar() {
 
   const getQueueIndicator = () => {
     const status = queueStatus();
+    let label: string;
     if (status.state === "busy") {
-      return `Processing (${status.pending_count})`;
+      label = `Processing (${status.pending_count})`;
+    } else if (status.state === "paused") {
+      label = `Paused (${status.pending_count})`;
+    } else if (status.pending_count > 0) {
+      label = `Waiting (${status.pending_count})`;
+    } else {
+      label = "Ready";
     }
-    if (status.state === "paused") {
-      return "Paused";
+    if (status.dlq_count > 0) {
+      label += ` [DLQ:${status.dlq_count}]`;
     }
-    return "Ready";
+    return label;
   };
 
   const getFocusIndicator = () => {
@@ -69,7 +76,7 @@ export function StatusBar() {
         </text>
       </Show>
 
-      <text fg={queueStatus().state === "busy" ? "#b58900" : "#586e75"}>
+      <text fg={queueStatus().state === "busy" ? "#b58900" : queueStatus().dlq_count > 0 ? "#dc322f" : queueStatus().pending_count > 0 ? "#2aa198" : "#586e75"}>
         {getQueueIndicator()}
       </text>
     </box>

package/tui/src/context/ei.tsx

@@ -32,6 +32,7 @@ import type {
   StateConflictData,
   StateConflictResolution,
   ContextStatus,
+  LLMRequest,
 } from "../../../src/core/types.js";
 
 interface EiStore {
@@ -57,6 +58,10 @@ export interface EiContextValue {
   refreshMessages: () => Promise<void>;
   abortCurrentOperation: () => Promise<void>;
   resumeQueue: () => Promise<void>;
+  pauseQueue: () => void;
+  getQueueActiveItems: () => LLMRequest[];
+  getDLQItems: () => LLMRequest[];
+  updateQueueItem: (id: string, updates: Partial<LLMRequest>) => Promise<boolean>;
   stopProcessor: () => Promise<void>;
   saveAndExit: () => Promise<{ success: boolean; error?: string }>;
   showNotification: (message: string, level: "error" | "warn" | "info") => void;
@@ -110,7 +115,7 @@ export const EiProvider: ParentComponent = (props) => {
     activePersonaId: null,
     activeContextBoundary: undefined,
     messages: [],
-    queueStatus: { state: "idle", pending_count: 0 },
+    queueStatus: { state: "idle", pending_count: 0, dlq_count: 0 },
     notification: null,
   });
 
@@ -210,6 +215,27 @@ export const EiProvider: ParentComponent = (props) => {
     await processor.resumeQueue();
   };
 
+  const pauseQueue = () => {
+    if (!processor) return;
+    logger.info("Pausing queue");
+    processor.pauseQueue();
+  };
+
+  const getQueueActiveItems = (): LLMRequest[] => {
+    if (!processor) return [];
+    return processor.getQueueActiveItems();
+  };
+
+  const getDLQItems = (): LLMRequest[] => {
+    if (!processor) return [];
+    return processor.getDLQItems();
+  };
+
+  const updateQueueItem = async (id: string, updates: Partial<LLMRequest>): Promise<boolean> => {
+    if (!processor) return false;
+    return processor.updateQueueItem(id, updates);
+  };
+
   const stopProcessor = async () => {
     if (processor) {
       await processor.stop();
@@ -506,11 +532,11 @@ export const EiProvider: ParentComponent = (props) => {
           logger.debug(`onQueueStateChanged called with state: ${state}`);
           if (processor) {
             processor.getQueueStatus().then((status) => {
-              setStore("queueStatus", { state: status.state, pending_count: status.pending_count });
+              setStore("queueStatus", { state: status.state, pending_count: status.pending_count, dlq_count: status.dlq_count });
               logger.debug(`store.queueStatus after setStore:`, store.queueStatus);
             });
           } else {
-            setStore("queueStatus", { state, pending_count: 0 });
+            setStore("queueStatus", { state, pending_count: 0, dlq_count: 0 });
           }
         },
         onContextBoundaryChanged: (personaId) => {
@@ -568,6 +594,10 @@ export const EiProvider: ParentComponent = (props) => {
     refreshMessages,
     abortCurrentOperation,
     resumeQueue,
+    pauseQueue,
+    getQueueActiveItems,
+    getDLQItems,
+    updateQueueItem,
     stopProcessor,
     saveAndExit,
     showNotification,

package/tui/src/context/keyboard.tsx

@@ -152,7 +152,7 @@ export const KeyboardProvider: ParentComponent = (props) => {
         }
       }
       // Navigate backward through sent-message history
-      const history = messages().filter(m => m.role === "human").map(m => m.content);
+      const history = messages().filter(m => m.role === "human").map(m => (m.verbal_response ?? ''));
       if (history.length === 0) return;
       if (historyIndex === -1) {
         savedDraft = textareaRef.plainText;
@@ -180,7 +180,7 @@ export const KeyboardProvider: ParentComponent = (props) => {
         textareaRef.gotoBufferEnd();
       } else {
         historyIndex -= 1;
-        const history = messages().filter(m => m.role === "human").map(m => m.content);
+        const history = messages().filter(m => m.role === "human").map(m => (m.verbal_response ?? ''));
         const entry = history[history.length - 1 - historyIndex];
         textareaRef.setText(entry);
         textareaRef.gotoBufferEnd();  // cursor at end so next Down continues forward

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

@@ -1,19 +1,22 @@
 import YAML from "yaml";
-import type { 
-  PersonaEntity, 
-  HumanEntity, 
+import type {
+  PersonaEntity,
+  HumanEntity,
   HumanSettings,
   CeremonyConfig,
   OpenCodeSettings,
-  Fact, 
-  Trait, 
-  Topic, 
+  Fact,
+  Trait,
+  Topic,
   Person,
   PersonaTopic,
   ProviderAccount,
   ProviderType,
   Quote,
   Message,
+  LLMRequest,
+  LLMRequestState,
+  LLMPriority,
 } from "../../../src/core/types.js";
 import { ContextStatus } from "../../../src/core/types.js";
 
@@ -719,13 +722,17 @@ interface EditableMessage {
   timestamp: string;
   context_status: ContextStatus;
   _delete?: boolean;
-  content: string;
+  // verbal_response | action_response | silence_reason
+  verbal_response?: string;
+  action_response?: string;
+  silence_reason?: string;
 }
 
 export function contextToYAML(messages: Message[]): string {
   const header = [
     "# context_status: default | always | never",
     "# _delete: true — permanently removes the message",
+    "# verbal_response | action_response | silence_reason",
   ].join("\n");
 
   const data: EditableMessage[] = messages.map((m) => ({
@@ -734,7 +741,9 @@ export function contextToYAML(messages: Message[]): string {
     timestamp: m.timestamp,
     context_status: m.context_status,
     _delete: false,
-    content: m.content,
+    verbal_response: m.verbal_response,
+    action_response: m.action_response,
+    silence_reason: m.silence_reason,
   }));
 
   return header + "\n" + YAML.stringify(data, { lineWidth: 0 });
@@ -761,3 +770,56 @@ export function contextFromYAML(yamlContent: string): ContextYAMLResult {
 
   return { messages, deletedMessageIds };
 }
+
+
+// =============================================================================
+// QUEUE ITEM YAML
+// =============================================================================
+
+export function queueItemsToYAML(items: LLMRequest[]): string {
+  const data = items.map(item => ({
+    id: item.id,
+    state: item.state,
+    created_at: item.created_at,
+    attempts: item.attempts,
+    last_attempt: item.last_attempt,
+    retry_after: item.retry_after,
+    type: item.type,
+    priority: item.priority,
+    next_step: item.next_step,
+    model: item.model,
+    data: item.data,
+    // NOTE: system/user prompts omitted (large); to requeue: set state='pending', attempts=0
+  }));
+  return YAML.stringify(data, { lineWidth: 0 });
+}
+
+export interface QueueItemUpdate {
+  id: string;
+  state: LLMRequestState;
+  attempts: number;
+  model?: string;
+  priority?: LLMPriority;
+  data?: Record<string, unknown>;
+}
+
+export function queueItemsFromYAML(yamlContent: string): QueueItemUpdate[] {
+  const data = YAML.parse(yamlContent) as QueueItemUpdate[];
+  if (!Array.isArray(data)) throw new Error("Expected a YAML array of queue items");
+  return data.map(item => {
+    if (!item.id) throw new Error(`Queue item missing 'id' field`);
+    if (!item.state) throw new Error(`Queue item ${item.id} missing 'state' field`);
+    const validStates: LLMRequestState[] = ["pending", "processing", "dlq"];
+    if (!validStates.includes(item.state)) {
+      throw new Error(`Queue item ${item.id} has invalid state '${item.state}'. Valid: ${validStates.join(", ")}`);
+    }
+    return {
+      id: item.id,
+      state: item.state,
+      attempts: typeof item.attempts === "number" ? item.attempts : 0,
+      model: item.model,
+      priority: item.priority,
+      data: item.data,
+    };
+  });
+}