ei-tui 0.9.4 → 1.0.1

package/README.md

@@ -83,7 +83,7 @@ Ei can operate with three types of input, and three types of output.
                        ^
                     Sessions
                        |
-                   [OpenCode]
+          [OpenCode / Claude Code / Cursor]
 ```
 
 ```
@@ -169,6 +169,22 @@ All sessions map to a single "Cursor" persona.
 
 Sessions are processed oldest-first, one per queue cycle, so Ei won't overwhelm your LLM provider on first run. See [TUI Readme](tui/README.md)
 
+## Document Import
+
+Got notes, journals, markdown files? You can feed them directly to Ei.
+
+**Web**: Open **☰ menu** → **My Data** → **Documents** tab. Drop a `.txt`, `.md`, or `.markdown` file and Ei gets to work.
+
+**TUI**:
+```bash
+/import ~/notes/my-journal.md
+/import /path/to/report.pdf
+```
+
+Ei splits the document into segments, runs them through the extraction pipeline, and pulls out facts, topics, people, and quotes — exactly like it does with your conversations. The extracted knowledge is attributed to a reserved persona called **Emmett** so it doesn't pollute your chat history.
+
+Both surfaces show you which documents have been imported and let you remove their extracted knowledge (web: Delete button in the Documents tab; TUI: `/unsource <source_tag>`).
+
 ## Built-in Tool Integrations
 
 Personas can use tools. Not just read-from-memory tools — *actual* tools. Web search. Your music. Your filesystem. Here's what ships with Ei out of the box:
@@ -184,6 +200,7 @@ Personas can use tools. Not just read-from-memory tools — *actual* tools. Web
 | `search_files` | Find files by name pattern *(TUI only)* |
 | `grep` | Search file contents by regex *(TUI only)* |
 | `get_file_info` | File/directory metadata *(TUI only)* |
+| `web_fetch` | Fetch a URL and return its text content *(TUI only — blocked by CORS in browsers)* |
 
 The filesystem tools make Ei a legitimate coding assistant in the TUI. Ask a persona to review a file, understand a project structure, or track down where something is defined — it can actually look.
 
@@ -264,13 +281,15 @@ Tag a version to publish automatically:
 
 ```bash
 # bump version in package.json
-git commit -am "chore: bump to v0.1.4"
-git tag v0.1.4
+git commit -am "chore: bump to v1.0.0"
+git tag v1.0.0
 git push && git push --tags
 ```
 
 GitHub Actions picks up the tag and publishes to npm with provenance via OIDC. No stored secrets.
 
+> **Note**: Run the pre-flight checklist in `AGENTS.md` (or use the `release` skill in OpenCode) before tagging. The v0.1.9 incident is a cautionary tale.
+
 ## Project Structure
 
 See `AGENTS.md` for detailed architecture and contribution guidelines.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ei-tui",
-  "version": "0.9.4",
+  "version": "1.0.1",
   "author": "Flare576",
   "repository": {
     "type": "git",
@@ -57,6 +57,10 @@
     "test:evals:topic-scan": "vite-node tests/evals/topic-scan.eval.ts",
     "test:evals:topic-match": "vite-node tests/evals/topic-match.eval.ts",
     "test:evals:topic-update": "vite-node tests/evals/topic-update.eval.ts",
+    "test:evals:topic-technical": "vite-node tests/evals/topic-technical.eval.ts",
+    "test:evals:rewrite-scan": "vite-node tests/evals/rewrite-scan.eval.ts",
+    "test:evals:rewrite-rewrite": "vite-node tests/evals/rewrite-rewrite.eval.ts",
+    "test:evals:rewrite-real-data": "vite-node tests/evals/rewrite-real-data.eval.ts",
     "test:evals:topic-validate": "vite-node tests/evals/topic-validate.eval.ts",
     "test:evals:person-scan": "vite-node tests/evals/person-scan.eval.ts",
     "test:evals:person-update": "vite-node tests/evals/person-update.eval.ts",

package/src/README.md

@@ -57,39 +57,23 @@ Each Topic will have an "exposure" rating similar to those on Human Data points.
 
 # Ceremony Intent
 
-Every 24 hours, we want to freshen up the system. We do this in 4 parts: Exposure, Decay, Expire, Explore
+Every 24 hours, the system runs a ceremony to keep knowledge fresh and healthy. Phases run sequentially via `ceremony_progress`:
 
-## Exposure
+**Phase 1 → Dedup**: User-triggered only (not automated). Merges confirmed duplicate records.
 
-I also frequently refer to this as "Extract," but this is the first step where we determine what the human and that Persona talked about that day. It serves two purposes:
+**Phase 2 → Expose**: Human extraction catch-up (facts, topics, people) + persona topic rating for any messages that didn't hit the per-send threshold during the day.
 
-### Detail Extraction
+**Phase 3 → EventSummary**: Summarizes significant events from recent conversations.
 
-Since we also pull out details during normal discourse (see above), this is the less-important step at this point, but still vital for catching up with the last few messages, or Personas that only received a few messages during the day and may not have hit the current limit for natural extraction.
+**Decay** (synchronous after Phase 3): Applies exposure decay to persona topics + prunes old messages. Human ceremony (decay for human topics/people) runs here too.
 
-### Exposure Adjustment
+**Phase 4 → Person Rewrite**: Scans bloated Person records (>750 chars) and extracts non-relationship content into Topics. Gated so Topic Rewrite can snapshot the updated Topic list afterward.
 
-Exposure is calculated by two metrics - `desired` and `current`. If an entity REALLY likes talking about a subject, their `desired` will be very high (1.0 max), ranging down to 0.0 for subjects which that entity does NOT wish to discuss. You may have guessed already, but `current` is how much they've recently talked about a topic.
+**Topic Rewrite** (fire-and-forget after Phase 4): Scans bloated Topic records (>750 chars) and splits them into focused sub-topics. Topics created by Person Rewrite are included.
 
-Adjusting the values is different for Human Topics/People than Persona Topics. The Human subjects are actually adjusted during the previous step, while extracting details.
+**Reflection** (fire-and-forget alongside Phase 4): Persona-side critic pass on person records.
 
-The Persona Topic update only happens during the Ceremony, and really this step only increases exposure IF the subject was discussed, bumping the last_updated field accordingly.
-
-## Decay
-
-After we determine if topics were discussed (increasing exposure), we adjust exposure the _other_ way. Based on some heuristics (like current level, desired level, and time-since-discussion), we decrease the current exposure levels down.
-
-## Expire
-
-This and the following step (Explore) are exclusive to Persona Topics right now. In Expire, we analyze the Person Topics to determine if any of them have
-- Lost their meaning to the Persona
-- Been ignored or dismissed by the user
-
-This is largely tracked by exposure, but expiration is dictated by an Agent.
-
-## Explore
-
-After we've removed irrelevant topics, this is the Agent's opportunity to add NEW topics that might be of interest to the Persona (and the user). Again, it's a prompt to an agent if the Persona doesn't have its full capacity of Topics.
+> **Note**: Expire and Explore phases were removed in the Persona Ceremony Simplification (2026-04-05). Persona topics now only update `exposure_current` during ceremony. See CONTRACTS.md changelog for details.
 
 # Opencode Importer
 

package/src/core/handlers/document-segmentation.ts

@@ -0,0 +1,113 @@
+import { ContextStatus } from "../types.js";
+import type { LLMResponse, Message } from "../types.js";
+import type { StateManager } from "../state-manager.js";
+import {
+  queueAllScans,
+  type ExtractionContext,
+} from "../orchestrators/human-extraction.js";
+
+function parseSegmentArray(content: string): string[] | null {
+  const jsonMatch = content.match(/```json\s*([\s\S]*?)```/) ?? content.match(/```\s*([\s\S]*?)```/);
+  const jsonText = jsonMatch ? jsonMatch[1].trim() : content.trim();
+
+  const arrayMatch = jsonText.match(/\[[\s\S]*\]/);
+  if (!arrayMatch) return null;
+
+  try {
+    const parsed = JSON.parse(arrayMatch[0]);
+    if (!Array.isArray(parsed)) return null;
+    return parsed.filter((item): item is string => typeof item === "string" && item.trim().length > 0);
+  } catch {
+    return null;
+  }
+}
+
+export function handleDocumentSegmentation(response: LLMResponse, state: StateManager): void {
+  const { batchId, filename, originalContent } = response.request.data as {
+    batchId: string;
+    filename: string;
+    originalContent: string;
+  };
+
+  if (!batchId || !filename) {
+    console.error("[handleDocumentSegmentation] Missing batchId or filename in request data");
+    return;
+  }
+
+  let segments: string[];
+  if (response.content) {
+    const parsed = parseSegmentArray(response.content);
+    segments = (parsed && parsed.length > 0) ? parsed : [originalContent];
+  } else {
+    segments = [originalContent];
+  }
+
+  const emmett = state.persona_getById("emmet");
+  if (!emmett) {
+    console.warn("[handleDocumentSegmentation] Emmett persona not found — skipping segment write");
+    return;
+  }
+
+  const now = new Date().toISOString();
+  const sourceTag = `import:document:${filename}`;
+
+  for (const segment of segments) {
+    const message: Message = {
+      id: crypto.randomUUID(),
+      role: "system",
+      content: segment,
+      timestamp: now,
+      read: true,
+      context_status: ContextStatus.Always,
+      external: true,
+      source_tag: sourceTag,
+    };
+    state.messages_append("emmet", message);
+  }
+
+  console.log(`[handleDocumentSegmentation] Wrote ${segments.length} segment(s) for batch ${batchId} (${filename})`);
+}
+
+export function finishDocumentBatch(batchId: string, filename: string, state: StateManager): void {
+  const sourceTag = `import:document:${filename}`;
+
+  const emmettMessages = state.messages_get("emmet");
+  const docMessages = emmettMessages.filter(m => m.external === true && m.source_tag === sourceTag);
+
+  if (docMessages.length === 0) {
+    console.warn(`[finishDocumentBatch] No messages found for ${sourceTag} — skipping extraction`);
+  } else {
+    const extractionContext: ExtractionContext = {
+      personaId: "emmet",
+      channelDisplayName: "Document",
+      messages_context: [],
+      messages_analyze: docMessages,
+      sources: [sourceTag],
+    };
+
+    const docSettings = state.getHuman().settings?.document;
+    queueAllScans(extractionContext, state, {
+      extraction_model: docSettings?.extraction_model,
+      external_filter: "only",
+    });
+
+    console.log(`[finishDocumentBatch] Queued extraction for ${docMessages.length} message(s) from ${filename}`);
+  }
+
+  const updatedHuman = state.getHuman();
+  state.setHuman({
+    ...updatedHuman,
+    settings: {
+      ...updatedHuman.settings,
+      document: {
+        ...updatedHuman.settings?.document,
+        processed_documents: {
+          ...(updatedHuman.settings?.document?.processed_documents ?? {}),
+          [filename]: new Date().toISOString(),
+        },
+      },
+    },
+  });
+
+  console.log(`[finishDocumentBatch] Batch ${batchId} complete, ${filename} marked processed`);
+}

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/handlers/index.ts

@@ -15,6 +15,7 @@ import { handleRewriteScan, handleRewriteRewrite } from "./rewrite.js";
 import { handleDedupCurate } from "./dedup.js";
 import { handleRoomResponse, handleRoomJudge } from "./rooms.js";
 import { handlePersonaPreview } from "./persona-preview.js";
+import { handleDocumentSegmentation } from "./document-segmentation.js";
 
 export const handlers: Record<LLMNextStep, ResponseHandler> = {
   handlePersonaResponse,
@@ -41,4 +42,5 @@ export const handlers: Record<LLMNextStep, ResponseHandler> = {
   handlePersonaPreview,
   [LLMNextStep.HandleTopicValidate]: handleDedupCurate,
   [LLMNextStep.HandleReflectionCritic]: handleReflectionCritic,
+  [LLMNextStep.HandleDocumentSegmentation]: handleDocumentSegmentation,
 };

package/src/core/handlers/rewrite.ts

@@ -14,7 +14,8 @@ import type {
   RewriteResult,
   RewriteSubjectMatch,
 } from "../../prompts/ceremony/types.js";
-import { buildRewritePrompt } from "../../prompts/ceremony/rewrite.js";
+import { buildPersonRewriteSplitPrompt } from "../../prompts/ceremony/people-rewrite.js";
+import { buildTopicRewriteSplitPrompt } from "../../prompts/ceremony/topic-rewrite.js";
 import { getEmbeddingService, getItemEmbeddingText } from "../embedding-service.js";
 
 import { searchHumanData } from "../human-data-manager.js";
@@ -79,12 +80,10 @@ export async function handleRewriteScan(response: LLMResponse, state: StateManag
     }
   }
 
-  // Build Phase 2 prompt and queue it
-  const prompt = buildRewritePrompt({
-    item: currentItem,
-    itemType,
-    subjects: subjectMatches,
-  });
+  const splitData = { item: currentItem, itemType, subjects: subjectMatches };
+  const prompt = itemType === "person"
+    ? buildPersonRewriteSplitPrompt(splitData)
+    : buildTopicRewriteSplitPrompt(splitData);
 
   state.queue_enqueue({
     type: LLMRequestType.JSON,
@@ -125,6 +124,11 @@ export async function handleRewriteRewrite(response: LLMResponse, state: StateMa
   const human = state.getHuman();
   const now = new Date().toISOString();
 
+  const originalItem = itemType === "topic"
+    ? human.topics.find(t => t.id === itemId)
+    : human.people.find(p => p.id === itemId);
+  const originalCategory = itemType === "topic" ? (originalItem as Topic | undefined)?.category : undefined;
+
   const allItems: DataItemBase[] = [
     ...human.topics, ...human.people,
   ];
@@ -228,11 +232,11 @@ export async function handleRewriteRewrite(response: LLMResponse, state: StateMa
     switch (item.type) {
       case "topic": {
         if (!item.category) {
-          console.warn(`[handleRewriteRewrite] New topic "${item.name}" missing category — defaulting to "Interest"`);
+          console.warn(`[handleRewriteRewrite] New topic "${item.name}" missing category — inheriting from original (${originalCategory ?? "Interest"})`);
         }
         const topic: Topic = {
           ...baseFields,
-          category: item.category ?? "Interest",
+          category: item.category ?? originalCategory ?? "Interest",
           exposure_current: 0.5,
           exposure_desired: 0.5,
         };

package/src/core/heartbeat-manager.ts

@@ -143,7 +143,7 @@ export async function queueEiHeartbeat(
   }
 
   const activePersonas = personas
-    .filter((p) => !p.is_archived && !p.is_paused && p.id !== "ei")
+    .filter((p) => !p.is_archived && !p.is_paused && !p.is_static && p.id !== "ei")
     .map((p) => {
       const msgs = sm.messages_get(p.id);
       const lastHuman = [...msgs].reverse().find((m) => m.role === "human");
@@ -169,7 +169,7 @@ export async function queueEiHeartbeat(
   }
 
   const personasWithPendingUpdate = personas.filter(
-    (p) => !p.is_archived && !p.is_paused && p.id !== "ei" && p.pending_update?.critique
+    (p) => !p.is_archived && !p.is_paused && !p.is_static && p.id !== "ei" && p.pending_update?.critique
   );
   for (const p of personasWithPendingUpdate) {
     items.push({

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(/\/+$/, "");
   
@@ -274,7 +308,18 @@ export async function callLLMRaw(
   };
 
   if (modelConfig?.thinking_budget !== undefined) {
-    requestBody.think = { budget_tokens: modelConfig.thinking_budget };
+    if (modelConfig.thinking_budget === 0) {
+      // 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 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 };
+    }
   }
 
   if (options.tools && options.tools.length > 0) {
@@ -296,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/message-manager.ts

@@ -177,25 +177,27 @@ export async function sendMessage(
 
   const history = sm.messages_get(persona.id);
 
-  const traitExtractionData: PersonaTraitExtractionPromptData = {
-    persona_name: persona.display_name,
-    current_traits: persona.traits,
-    messages_context: history.slice(-11, -1),
-    messages_analyze: [message],
-  };
-  const traitPrompt = buildPersonaTraitExtractionPrompt(traitExtractionData);
-
-  sm.queue_enqueue({
-    type: LLMRequestType.JSON,
-    priority: LLMPriority.Low,
-    system: traitPrompt.system,
-    user: traitPrompt.user,
-    next_step: LLMNextStep.HandlePersonaTraitExtraction,
-    model: getModelForPersona(persona.id),
-    data: { personaId: persona.id, personaDisplayName: persona.display_name },
-  });
+  if (!persona.is_static) {
+    const traitExtractionData: PersonaTraitExtractionPromptData = {
+      persona_name: persona.display_name,
+      current_traits: persona.traits,
+      messages_context: history.slice(-11, -1),
+      messages_analyze: [message],
+    };
+    const traitPrompt = buildPersonaTraitExtractionPrompt(traitExtractionData);
+
+    sm.queue_enqueue({
+      type: LLMRequestType.JSON,
+      priority: LLMPriority.Low,
+      system: traitPrompt.system,
+      user: traitPrompt.user,
+      next_step: LLMNextStep.HandlePersonaTraitExtraction,
+      model: getModelForPersona(persona.id),
+      data: { personaId: persona.id, personaDisplayName: persona.display_name },
+    });
 
-  checkAndQueueHumanExtraction(sm, persona.id, persona.display_name, history);
+    checkAndQueueHumanExtraction(sm, persona.id, persona.display_name, history);
+  }
 }
 
 // =============================================================================