ei-tui 1.0.0 → 1.0.1

package/package.json

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

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

@@ -92,7 +92,7 @@ export async function handleFactFind(response: LLMResponse, state: StateManager)
   markMessagesExtracted(response, state, "f");
   
   if (!result?.facts || !Array.isArray(result.facts)) {
-    console.log("[handleFactFind] No facts detected or invalid result");
+    console.debug("[handleFactFind] No facts detected or invalid result");
     return;
   }
 
@@ -106,26 +106,26 @@ export async function handleFactFind(response: LLMResponse, state: StateManager)
   for (const factResult of result.facts) {
     // Only upsert facts that match a built-in name
     if (!BUILT_IN_FACT_NAMES.has(factResult.name)) {
-      console.log(`[handleFactFind] Skipping non-built-in fact: "${factResult.name}"`);
+      console.warn(`[handleFactFind] Skipping non-built-in fact: "${factResult.name}"`);
       continue;
     }
 
     // Find the existing fact in state
     const existingFact = human.facts.find(f => f.name === factResult.name);
     if (!existingFact) {
-      console.log(`[handleFactFind] Skipping unknown fact: "${factResult.name}"`);
+      console.warn(`[handleFactFind] Skipping unknown fact: "${factResult.name}"`);
       continue;
     }
 
     // Skip facts that already have descriptions (only fill empty ones)
     if (existingFact.description && existingFact.description !== "") {
-      console.log(`[handleFactFind] Skipping fact with existing description: "${factResult.name}"`);
+      console.debug(`[handleFactFind] Skipping fact with existing description: "${factResult.name}"`);
       continue;
     }
 
     // Skip if the LLM returned a null/empty/non-string value — don't store booleans or nulls
     if (!factResult.value || typeof factResult.value !== 'string') {
-      console.log(`[handleFactFind] Skipping fact with null/empty/non-string value: "${factResult.name}" (got ${typeof factResult.value})`);
+      console.warn(`[handleFactFind] Skipping fact with null/empty/non-string value: "${factResult.name}" (got ${typeof factResult.value})`);
       continue;
     }
 
@@ -165,7 +165,7 @@ export async function handleHumanTopicScan(response: LLMResponse, state: StateMa
   markMessagesExtracted(response, state, "t");
   
   if (!result?.topics || !Array.isArray(result.topics)) {
-    console.log("[handleHumanTopicScan] No topics detected or invalid result");
+    console.debug("[handleHumanTopicScan] No topics detected or invalid result");
     return;
   }
 
@@ -185,7 +185,7 @@ export async function handleHumanPersonScan(response: LLMResponse, state: StateM
   markMessagesExtracted(response, state, "p");
   
   if (!result?.people || !Array.isArray(result.people)) {
-    console.log("[handleHumanPersonScan] No people detected or invalid result");
+    console.debug("[handleHumanPersonScan] No people detected or invalid result");
     return;
   }
 
@@ -231,7 +231,7 @@ export async function handleHumanPersonScan(response: LLMResponse, state: StateM
           }
         }
         if (!matchedPerson) {
-          console.log(`[handleHumanPersonScan] Multi-match for "${candidate.name}" (${matches.length} hits) — no embedding above threshold, creating new record`);
+          console.debug(`[handleHumanPersonScan] Multi-match for "${candidate.name}" (${matches.length} hits) — no embedding above threshold, creating new record`);
         }
       } catch (err) {
         console.warn(`[handleHumanPersonScan] Multi-match embedding failed for "${candidate.name}", using first match:`, err);
@@ -253,7 +253,7 @@ export async function handleHumanPersonScan(response: LLMResponse, state: StateM
         if (isUnknownPlaceholder || isSingleton) {
           matchedPerson = existing;
           const reason = isUnknownPlaceholder ? 'unnamed placeholder' : 'singleton relationship';
-          console.log(`[handleHumanPersonScan] Relationship unique match: "${candidate.name}" → "${existing.name}" (sole ${candidate.relationship}, ${reason})`);
+          console.debug(`[handleHumanPersonScan] Relationship unique match: "${candidate.name}" → "${existing.name}" (sole ${candidate.relationship}, ${reason})`);
         }
       } else {
         // N>1 same relationship → cosine within that subset.
@@ -267,7 +267,7 @@ export async function handleHumanPersonScan(response: LLMResponse, state: StateM
           : `all ${human.people.length} people`;
 
         if (searchPool.length > 0) {
-          console.log(`[handleHumanPersonScan] "${candidate.name}": cosine against ${searchPool.length} embedded (${poolLabel})`);
+          console.debug(`[handleHumanPersonScan] "${candidate.name}": cosine against ${searchPool.length} embedded (${poolLabel})`);
           try {
             const embeddingService = getEmbeddingService();
             const candidateText = getPersonEmbeddingText({
@@ -288,15 +288,15 @@ export async function handleHumanPersonScan(response: LLMResponse, state: StateM
             }
             const top3 = scores.sort((a, b) => b.sim - a.sim).slice(0, 3).map(s => `"${s.name}"=${s.sim.toFixed(3)}`).join(', ');
             if (matchedPerson) {
-              console.log(`[handleHumanPersonScan] Cosine matched "${candidate.name}" → "${matchedPerson.name}" (${bestSimilarity.toFixed(3)}) | top3: ${top3}`);
+              console.debug(`[handleHumanPersonScan] Cosine matched "${candidate.name}" → "${matchedPerson.name}" (${bestSimilarity.toFixed(3)}) | top3: ${top3}`);
             } else {
-              console.log(`[handleHumanPersonScan] Cosine: no match above ${ZERO_MATCH_COSINE_THRESHOLD} for "${candidate.name}" | top3: ${top3}`);
+              console.debug(`[handleHumanPersonScan] Cosine: no match above ${ZERO_MATCH_COSINE_THRESHOLD} for "${candidate.name}" | top3: ${top3}`);
             }
           } catch (err) {
             console.warn(`[handleHumanPersonScan] Cosine failed for "${candidate.name}":`, err);
           }
         } else {
-          console.log(`[handleHumanPersonScan] "${candidate.name}": no embedded people in pool (${poolLabel}) — new person`);
+          console.debug(`[handleHumanPersonScan] "${candidate.name}": no embedded people in pool (${poolLabel}) — new person`);
         }
       }
     }
@@ -305,7 +305,7 @@ export async function handleHumanPersonScan(response: LLMResponse, state: StateM
       const linkedPersonaId = matchedPerson.identifiers
         ?.find(i => i.type === "Ei Persona")?.value;
       if (linkedPersonaId) {
-        console.log(`[handleHumanPersonScan] Skipping update for "${candidate.name}" — scan marked as reflection drain (reflection_progress=1)`);
+        console.debug(`[handleHumanPersonScan] Skipping update for "${candidate.name}" — scan marked as reflection drain (reflection_progress=1)`);
         continue;
       }
     }
@@ -326,7 +326,7 @@ export async function handleHumanPersonScan(response: LLMResponse, state: StateM
       : matches.length > 1
         ? `multi-match ambiguous (${matches.length} hits) — new record`
         : "no match (new person)";
-    console.log(`[handleHumanPersonScan] person "${candidate.name}": ${matched}`);
+    console.debug(`[handleHumanPersonScan] person "${candidate.name}": ${matched}`);
   }
   console.log(`[handleHumanPersonScan] Processed ${result.people.length} person(s)`);
 }
@@ -337,7 +337,7 @@ export async function handleEventScan(response: LLMResponse, state: StateManager
   const result = response.parsed as { events?: Array<{ name: string; description: string; reason: string }> } | undefined;
 
   if (!result?.events || !Array.isArray(result.events) || result.events.length === 0) {
-    console.log("[handleEventScan] No epic events detected");
+    console.debug("[handleEventScan] No epic events detected");
     return;
   }
 

package/src/core/llm-client.ts

@@ -2,6 +2,36 @@ import type { ChatMessage, ProviderAccount, ModelConfig } from "./types.js";
 const DEFAULT_TOKEN_LIMIT = 8192;
 const DEFAULT_MAX_OUTPUT_TOKENS = 8000;
 
+// Lazy verbose network dump — only active when EI_DEBUG_NETWORK_VERBOSE=1.
+// Uses dynamic import so the web bundle never pulls in node:fs.
+async function writeNetworkDump(
+  callNumber: number,
+  nextStep: string,
+  meta: { model: string; provider: string; latency_ms: number; status_code: number; tokens_in: number; tokens_out: number },
+  request: unknown,
+  response: unknown
+): Promise<void> {
+  const dataPath = (typeof process !== "undefined" && process.env?.EI_DATA_PATH) ||
+    (typeof Bun !== "undefined" && (Bun as Record<string, unknown>).env && ((Bun as { env: Record<string, string> }).env.EI_DATA_PATH));
+  if (!dataPath) return;
+
+  try {
+    const { mkdirSync, writeFileSync } = await import("node:fs");
+    const { join } = await import("node:path");
+    const logsDir = join(dataPath as string, "logs");
+    mkdirSync(logsDir, { recursive: true });
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const safeName = nextStep.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const filename = join(logsDir, `${timestamp}_call${callNumber}_${safeName}.json`);
+
+    const payload = JSON.stringify({ meta, request, response }, null, 2);
+    writeFileSync(filename, payload);
+  } catch {
+    // Silent — verbose dump failures must never crash the main path
+  }
+}
+
 export interface ProviderConfig {
   baseURL: string;
   apiKey: string;
@@ -22,6 +52,8 @@ export interface LLMCallOptions {
   tools?: Record<string, unknown>[];
   /** Fire-and-forget callback invoked after a successful response to increment usage counters. */
   onUsageUpdate?: (modelId: string, usage: { calls: number; tokens_in: number; tokens_out: number }) => void;
+  /** Queue step name passed through to EI_DEBUG_NETWORK_VERBOSE file dumps. */
+  nextStep?: string;
 }
 
 export interface LLMRawResponse {
@@ -212,7 +244,7 @@ function logTokenLimit(model: string, source: string, tokens: number): void {
   if (source === "default") {
     console.warn(`[TokenLimit] Unknown model "${model}" — using conservative default (${DEFAULT_TOKEN_LIMIT})`);
   } else {
-    console.log(`[TokenLimit] ${model}: ${source} → ${tokens} tokens (extraction budget: ${budget})`);
+    console.debug(`[TokenLimit] ${model}: ${source} → ${tokens} tokens (extraction budget: ${budget})`);
   }
 }
 
@@ -226,7 +258,7 @@ export async function callLLMRaw(
 ): Promise<LLMRawResponse> {
   llmCallCount++;
   
-  const { signal, temperature = 0.7, onUsageUpdate } = options;
+  const { signal, temperature = 0.7, onUsageUpdate, nextStep = "unknown" } = options;
   
   if (signal?.aborted) {
     throw new Error("LLM call aborted");
@@ -251,7 +283,9 @@ export async function callLLMRaw(
   
   const totalChars = finalMessages.reduce((sum, m) => sum + (m.content?.length ?? 0), 0);
   const estimatedTokens = Math.ceil(totalChars / 4);
-  console.log(`[LLM] Call #${llmCallCount} - ~${estimatedTokens} tokens (${totalChars} chars)`);
+  const modelLabel = model ?? "default";
+  console.log(`[LLM] Call #${llmCallCount} — ${config.name}:${modelLabel}, ~${estimatedTokens} tokens est.`);
+  const _llmCallStart = Date.now();
   
   const normalizedBaseURL = config.baseURL.replace(/\/+$/, "");
   
@@ -275,14 +309,15 @@ export async function callLLMRaw(
 
   if (modelConfig?.thinking_budget !== undefined) {
     if (modelConfig.thinking_budget === 0) {
-      // Universal kill switch — works on Ollama, LM Studio, and all OpenAI-compat providers.
-      requestBody.reasoning_effort = "none";
+      // Universal kill switch across all known providers. Non-conflicting — each reads
+      // whichever field it understands and ignores the rest.
+      requestBody.reasoning_effort = "none";  // Ollama, OpenAI-compat
+      requestBody.enable_thinking = false;    // Rapid-MLX
     } else {
-      // Pass both signals: providers that honor the token budget get it (Qwen3 via Ollama,
-      // Anthropic), providers that reduce thinking to on/off use reasoning_effort as the
-      // on-signal (Gemma4 via Ollama/LM Studio). Non-conflicting — each provider reads
-      // whichever field it understands.
+      // Pass all on-signals: providers that honor the token budget get it (Qwen3, Anthropic),
+      // providers that reduce thinking to on/off use reasoning_effort or enable_thinking.
       requestBody.reasoning_effort = "high";
+      requestBody.enable_thinking = true;
       requestBody.think = { budget_tokens: modelConfig.thinking_budget };
     }
   }
@@ -306,9 +341,24 @@ export async function callLLMRaw(
   
   const data = await response.json();
 
+  const _llmLatency = Date.now() - _llmCallStart;
+  const tokensIn = data.usage?.prompt_tokens ?? data.usage?.input_tokens ?? 0;
+  const tokensOut = data.usage?.completion_tokens ?? data.usage?.output_tokens ?? 0;
+  console.log(`[LLM] Response #${llmCallCount} — ${response.status} ${_llmLatency}ms | in: ${tokensIn} out: ${tokensOut}`);
+
+  const isVerbose = (typeof process !== "undefined" && process.env?.EI_DEBUG_NETWORK_VERBOSE === "1") ||
+    (typeof Bun !== "undefined" && (Bun as { env: Record<string, string> }).env?.EI_DEBUG_NETWORK_VERBOSE === "1");
+  if (isVerbose) {
+    void writeNetworkDump(
+      llmCallCount,
+      nextStep,
+      { model: modelLabel, provider: config.name, latency_ms: _llmLatency, status_code: response.status, tokens_in: tokensIn, tokens_out: tokensOut },
+      requestBody,
+      data
+    );
+  }
+
   if (onUsageUpdate && modelConfig) {
-    const tokensIn = data.usage?.prompt_tokens ?? data.usage?.input_tokens ?? 0;
-    const tokensOut = data.usage?.completion_tokens ?? data.usage?.output_tokens ?? 0;
     onUsageUpdate(modelConfig.id, { calls: 1, tokens_in: tokensIn, tokens_out: tokensOut });
   }
 

package/src/core/queue-processor.ts

@@ -200,7 +200,7 @@ export class QueueProcessor {
         hydratedUser,
         messages,
         request.model,
-        { signal: this.abortController?.signal, tools: openAITools, onUsageUpdate: this.currentOnUsageUpdate },
+        { signal: this.abortController?.signal, tools: openAITools, onUsageUpdate: this.currentOnUsageUpdate, nextStep: `${request.data.originalNextStep ?? request.next_step}+tool_continuation` },
         this.currentAccounts
       );
 
@@ -219,7 +219,7 @@ export class QueueProcessor {
             if (!args.should_respond && args.content) {
               args.should_respond = true;
             }
-            console.log(`[QueueProcessor] submit tool "${submitCall.name}" called — returning arguments as parsed response`);
+      console.debug(`[QueueProcessor] submit tool "${submitCall.name}" called — returning arguments as parsed response`);
             return {
               request,
               success: true,
@@ -297,9 +297,9 @@ export class QueueProcessor {
     const isHeartbeat = request.next_step === LLMNextStep.HandleHeartbeatCheck || request.next_step === LLMNextStep.HandleEiHeartbeat;
     if (isHeartbeat) {
       const personaName = request.data.personaDisplayName as string | undefined ?? 'Ei';
-      console.log(`[${personaName} Heartbeat] LLM call - tools offered: ${openAITools.length} (${activeTools.map(t => t.name).join(', ') || 'none'})`);
+      console.debug(`[${personaName} Heartbeat] LLM call - tools offered: ${openAITools.length} (${activeTools.map(t => t.name).join(', ') || 'none'})`);
     } else {
-      console.log(`[QueueProcessor] LLM call for ${request.next_step}, tools=${openAITools.length}`);
+      console.debug(`[QueueProcessor] LLM call for ${request.next_step}, tools=${openAITools.length}`);
     }
 
     const { content, finishReason, rawToolCalls, assistantMessage, thinking } = await callLLMRaw(
@@ -307,18 +307,18 @@ export class QueueProcessor {
       hydratedUser,
       messages,
       request.model,
-      { signal: this.abortController?.signal, tools: openAITools, onUsageUpdate: this.currentOnUsageUpdate },
+      { signal: this.abortController?.signal, tools: openAITools, onUsageUpdate: this.currentOnUsageUpdate, nextStep: request.next_step },
       this.currentAccounts
     );
     if (thinking) {
-      console.log(`[QueueProcessor] Extended thinking on ${request.next_step} (${thinking.length} chars) — TODO(#13): stream to TUI`);
+      console.debug(`[QueueProcessor] Extended thinking on ${request.next_step} (${thinking.length} chars) — TODO(#13): stream to TUI`);
     }
 
     // =========================================================================
     // Tool call path: execute tools, enqueue HandleToolContinuation, done.
     // =========================================================================
     if (finishReason === "tool_calls" && rawToolCalls?.length) {
-      console.log(`[QueueProcessor] finish_reason=tool_calls — executing tools, will enqueue HandleToolContinuation`);
+      console.debug(`[QueueProcessor] finish_reason=tool_calls — executing tools, will enqueue HandleToolContinuation`);
 
       const toolCalls = parseToolCalls(rawToolCalls);
       if (toolCalls.length === 0) {
@@ -364,7 +364,7 @@ export class QueueProcessor {
         });
       }
 
-      console.log(`[QueueProcessor] Tool execution complete: ${results.length} result(s). Enqueueing HandleToolContinuation.`);
+      console.debug(`[QueueProcessor] Tool execution complete: ${results.length} result(s). Enqueueing HandleToolContinuation.`);
 
       if (this.currentOnEnqueue) {
         this.currentOnEnqueue({
@@ -412,7 +412,7 @@ export class QueueProcessor {
     // =========================================================================
     // Normal stop path
     // =========================================================================
-    console.log(`[QueueProcessor] finish_reason="${finishReason}" — normal stop`);
+    console.debug(`[QueueProcessor] finish_reason="${finishReason}" — normal stop`);
     return this.handleResponseType(request, content ?? "", finishReason);
   }
 
@@ -497,9 +497,9 @@ export class QueueProcessor {
       const { content: reformatContent, finishReason: reformatReason } = await callLLMRaw(
         request.system,
         reformatUserPrompt,
-        messages, // existing tool history — gives full context without duplicating the ask
+        messages,
         request.model,
-        { signal: this.abortController?.signal, onUsageUpdate: this.currentOnUsageUpdate },
+        { signal: this.abortController?.signal, onUsageUpdate: this.currentOnUsageUpdate, nextStep: `${request.data.originalNextStep ?? request.next_step}+prose_reformat` },
         this.currentAccounts
       );
 
@@ -554,9 +554,9 @@ export class QueueProcessor {
       const { content: reformatContent, finishReason: reformatReason } = await callLLMRaw(
         request.system,
         reformatUserPrompt,
-        [], // no message history needed — schema is already in the system prompt
+        [],
         request.model,
-        { signal: this.abortController?.signal, onUsageUpdate: this.currentOnUsageUpdate },
+        { signal: this.abortController?.signal, onUsageUpdate: this.currentOnUsageUpdate, nextStep: `${request.next_step}+json_reformat` },
         this.currentAccounts
       );
 

package/src/core/state-manager.ts

@@ -1054,7 +1054,7 @@ export class StateManager {
   tools_getForPersona(personaId: string, isTUI: boolean): ToolDefinition[] {
     const persona = this.personaState.getById(personaId);
     if (!persona?.tools?.length) {
-      console.log(`[Tools] tools_getForPersona(${personaId}): persona has no assigned tools`);
+      console.debug(`[Tools] tools_getForPersona(${personaId}): persona has no assigned tools`);
       return [];
     }
     const assignedIds = new Set(persona.tools);
@@ -1077,13 +1077,13 @@ export class StateManager {
     if (result.length < assignedIds.size) {
       for (const id of assignedIds) {
         const tool = this.tools.find(t => t.id === id);
-        if (!tool) { console.log(`[Tools] tools_getForPersona: assigned tool id=${id} not found in registry`); continue; }
-        if (!tool.enabled) { console.log(`[Tools] tools_getForPersona: tool "${tool.name}" is disabled`); continue; }
-        if (!enabledProviderIds.has(tool.provider_id)) { console.log(`[Tools] tools_getForPersona: tool "${tool.name}" provider is disabled`); continue; }
-        if (!(tool.runtime === "any" || (tool.runtime === "node" && isTUI))) { console.log(`[Tools] tools_getForPersona: tool "${tool.name}" runtime "${tool.runtime}" not available (isTUI=${isTUI})`); continue; }
+        if (!tool) { console.debug(`[Tools] tools_getForPersona: assigned tool id=${id} not found in registry`); continue; }
+        if (!tool.enabled) { console.debug(`[Tools] tools_getForPersona: tool "${tool.name}" is disabled`); continue; }
+        if (!enabledProviderIds.has(tool.provider_id)) { console.debug(`[Tools] tools_getForPersona: tool "${tool.name}" provider is disabled`); continue; }
+        if (!(tool.runtime === "any" || (tool.runtime === "node" && isTUI))) { console.debug(`[Tools] tools_getForPersona: tool "${tool.name}" runtime "${tool.runtime}" not available (isTUI=${isTUI})`); continue; }
       }
     }
-    console.log(`[Tools] tools_getForPersona(${personaId}): resolved ${result.length}/${assignedIds.size} tools: [${result.map(t => t.name).join(", ")}]`);
+    console.debug(`[Tools] tools_getForPersona(${personaId}): resolved ${result.length}/${assignedIds.size} tools: [${result.map(t => t.name).join(", ")}]`);
     return result;
   }
 

package/tui/README.md

@@ -168,9 +168,10 @@ Rooms have three modes, set at creation time:
 | `XDG_DATA_HOME` | `~/.local/share` | XDG base directory. Ignored if `EI_DATA_PATH` is set. |
 | `EI_SYNC_USERNAME` | — | Username for remote sync. If set at startup, bootstraps sync credentials automatically (useful for dotfiles/scripts). |
 | `EI_SYNC_PASSPHRASE` | — | Passphrase for remote sync. Paired with `EI_SYNC_USERNAME`. |
-| `EDITOR` / `VISUAL` | `vi` | Editor opened by `/details`, `/me`, `/settings`, `/context`, `/quotes`, etc. Falls back to `VISUAL` if `EDITOR` is unset. |
+| `EI_LOG_LEVEL` | `warn` | Log verbosity written to `tui.log`: `error`, `warn`, `info`, `debug`. |
+| `EI_DEBUG_NETWORK_VERBOSE` | — | Set to `1` to dump full LLM request/response payloads as JSON files under `$EI_DATA_PATH/logs/`. One file per call, named `TIMESTAMP_callN_STEP.json`. |
 
-> **Tip**: `tail -f $EI_DATA_PATH/tui.log` to watch live debug output.
+> **Tip**: `tail -f $EI_DATA_PATH/tui.log` to watch live TUI output. Set `EI_LOG_LEVEL=info` to see LLM call summaries (model, latency, token counts). Set `EI_DEBUG_NETWORK_VERBOSE=1` to dump full request/response payloads to `$EI_DATA_PATH/logs/`.
 
 
 # Development

package/tui/src/util/logger.ts

@@ -22,7 +22,7 @@ const LOG_LEVELS: Record<LogLevel, number> = {
   error: 3,
 };
 
-const currentLevel: LogLevel = (Bun.env.EI_LOG_LEVEL as LogLevel) || "debug";
+const currentLevel: LogLevel = (Bun.env.EI_LOG_LEVEL as LogLevel) || "warn";
 
 function shouldLog(level: LogLevel): boolean {
   return LOG_LEVELS[level] >= LOG_LEVELS[currentLevel];