ei-tui 1.6.8 → 1.7.0

package/src/core/processor.ts

@@ -23,10 +23,14 @@ import {
   type ToolDefinition,
   type ToolProvider,
 } from "./types.js";
+import { isReservedPersonaId } from "./types.js";
 import { buildPersonaFromPersonPrompt } from "../prompts/index.js";
 import { buildSiblingAwarenessSection } from "../prompts/room/index.js";
 import type { PersonaGenerationResult } from "../prompts/generation/types.js";
 
+import { readCorrections, assertValidCorrection } from "./corrections.js";
+import type { CorrectionRecord } from "./corrections.js";
+import { withLock, atomicWrite } from "../storage/file-lock.js";
 import type { Storage } from "../storage/interface.js";
 import { remoteSync } from "../storage/remote.js";
 import { yoloMerge } from "../storage/merge.js";
@@ -726,7 +730,115 @@ const toolNextSteps = new Set([
     console.log(`[Processor ${this.instanceId}] runLoop() exited`);
   }
 
+  /**
+   * Drain corrections.json into the live StateManager, every tick (no
+   * time-gating — corrections need near-instant pickup, that's the whole
+   * point of the external write path). Read + apply + delete all happen
+   * inside one withLock() call so a concurrent CLI appendCorrection() can't
+   * race the read-drain-delete sequence and lose a correction appended
+   * mid-drain.
+   *
+   * A malformed record (bad entity_type, or a StateManager call that
+   * throws) is dropped with a loud console.error rather than aborting the
+   * whole batch — corrections.json is external input from CLI/MCP tools
+   * potentially driven by an LLM agent, so one bad record must not wedge
+   * every subsequent correction behind it forever. This mirrors the
+   * existing DLQ/heartbeat error-tolerance philosophy in this file: log
+   * loudly, keep the loop alive, keep draining valid records.
+   */
+  private async drainCorrections(): Promise<void> {
+    if (!this.storage) return;
+    try {
+      const dataPath = this.storage.getDataPath();
+      // Web's IndexedDBStorage/LocalStorage return "" — no filesystem, no
+      // corrections.json to drain. This mechanism is filesystem-only
+      // (TUI/future daemon); Web sessions never write corrections.json in
+      // the first place since the CLI/MCP tools that produce it are Node/Bun-only.
+      if (!dataPath) return;
+      const { join } = await import(/* @vite-ignore */ "path");
+      const correctionsPath = join(dataPath, "corrections.json");
+
+      // Cheap fast path: this runs every 100ms, and readCorrections()
+      // short-circuits on a missing file without touching the lock.
+      const pending = await readCorrections(correctionsPath);
+      if (pending.length === 0) return;
+
+      await withLock(correctionsPath, async () => {
+        // Re-read inside the lock in case a correction was appended between
+        // the unlocked fast-path read above and lock acquisition.
+        const records = await readCorrections(correctionsPath);
+        if (records.length === 0) return;
+
+        for (const record of records) {
+          try {
+            this.applyCorrectionRecord(record);
+          } catch (err) {
+            console.error(`[Processor ${this.instanceId}] Dropping malformed correction record:`, JSON.stringify(record), err);
+          }
+        }
+
+        await atomicWrite(correctionsPath, "[]");
+        this.interface.onHumanUpdated?.();
+      });
+    } catch (err) {
+      console.error(`[Processor ${this.instanceId}] Failed to drain corrections.json:`, err);
+    }
+  }
+
+  /** Dispatch one CorrectionRecord to the matching StateManager upsert/remove call. Throws on an unrecognized entity_type or op (see assertValidCorrection — the same validator the CLI read-merge/self-drain path uses, so a malformed op can never be silently treated as its sibling operation here). */
+  private applyCorrectionRecord(record: CorrectionRecord): void {
+    assertValidCorrection(record);
+    if (record.entity_type === "fact") {
+      if (record.op === "upsert") {
+        this.stateManager.human_fact_upsert(record.record as Fact);
+      } else {
+        this.stateManager.human_fact_remove(record.id);
+      }
+    } else if (record.entity_type === "topic") {
+      if (record.op === "upsert") {
+        this.stateManager.human_topic_upsert(record.record as Topic);
+      } else {
+        this.stateManager.human_topic_remove(record.id);
+      }
+    } else if (record.entity_type === "person") {
+      if (record.op === "upsert") {
+        this.stateManager.human_person_upsert(record.record as Person);
+      } else {
+        this.stateManager.human_person_remove(record.id);
+      }
+    } else if (record.entity_type === "quote") {
+      if (record.op === "upsert") {
+        this.stateManager.human_quote_upsert(record.record as Quote);
+      } else {
+        this.stateManager.human_quote_remove(record.id);
+      }
+    } else if (record.entity_type === "persona") {
+      if (record.op === "upsert") {
+        const existing = this.stateManager.persona_getById(record.id);
+        if (existing) {
+          this.stateManager.persona_replace(record.id, record.record as PersonaEntity);
+        } else {
+          this.stateManager.persona_add(record.record as PersonaEntity);
+        }
+      } else {
+        // Defense in depth — this should never reach here since the
+        // synchronous write-time guard in src/cli/persona-corrections.ts's
+        // removePersonaEntity already rejects a reserved id before ever
+        // queuing the correction. corrections.json is external input,
+        // though, and could theoretically be hand-edited to bypass that.
+        if (isReservedPersonaId(record.id)) {
+          throw new Error(`Cannot delete reserved persona "${record.id}". Use archive instead.`);
+        }
+        this.stateManager.persona_delete(record.id);
+      }
+    } else {
+      throw new Error(`Unrecognized correction entity_type: ${JSON.stringify(record)}`);
+    }
+  }
+
   private async checkScheduledTasks(): Promise<void> {
+    await this.drainCorrections();
+
     const now = Date.now();
 
     const human = this.stateManager.getHuman();
@@ -1291,7 +1403,7 @@ const toolNextSteps = new Set([
   }
 
   async upsertPerson(person: Person): Promise<void> {
-    const sanitized = { ...person, identifiers: sanitizeEiPersonaIdentifiers(person.identifiers ?? [], this.stateManager) };
+    const sanitized = { ...person, identifiers: sanitizeEiPersonaIdentifiers(person.identifiers ?? [], this.stateManager.persona_getAll()) };
     await upsertPerson(this.stateManager, sanitized);
     this.interface.onHumanUpdated?.();
   }

package/src/core/state/human.ts

@@ -118,6 +118,16 @@ export class HumanState {
      return false;
    }
 
+   quote_upsert(quote: Quote): void {
+     const idx = this.human.quotes.findIndex((q) => q.id === quote.id);
+     if (idx >= 0) {
+       this.human.quotes[idx] = quote;
+     } else {
+       this.human.quotes.push(quote);
+     }
+     this.human.last_updated = new Date().toISOString();
+   }
+
    quote_add(quote: Quote): void {
      if (!quote.created_at) {
        quote.created_at = new Date().toISOString();

package/src/core/state/personas.ts

@@ -80,6 +80,14 @@ export class PersonaState {
     return true;
   }
 
+  /** Full replace of a persona's entity (not a merge) — used by the live-drain path for corrections-queue upserts, where record.record is already a complete PersonaEntity and any field genuinely absent from it must NOT survive from the prior value. Preserves .messages untouched, same as update(). */
+  replace(personaId: string, entity: PersonaEntity): boolean {
+    const data = this.personas.get(personaId);
+    if (!data) return false;
+    data.entity = { ...entity, last_updated: new Date().toISOString() };
+    return true;
+  }
+
   archive(personaId: string): boolean {
     const data = this.personas.get(personaId);
     if (!data) return false;

package/src/core/state-manager.ts

@@ -715,6 +715,11 @@ export class StateManager {
     this.scheduleSave();
   }
 
+  human_quote_upsert(quote: Quote): void {
+    this.humanState.quote_upsert(quote);
+    this.scheduleSave();
+  }
+
   human_quote_update(id: string, updates: Partial<Quote>): boolean {
     const result = this.humanState.quote_update(id, updates);
     this.scheduleSave();
@@ -758,6 +763,12 @@ export class StateManager {
     return result;
   }
 
+  persona_replace(personaId: string, entity: PersonaEntity): boolean {
+    const result = this.personaState.replace(personaId, entity);
+    this.scheduleSave();
+    return result;
+  }
+
   persona_archive(personaId: string): boolean {
     const result = this.personaState.archive(personaId);
     this.scheduleSave();

package/src/core/types/entities.ts

@@ -60,6 +60,7 @@ export interface ModelConfig {
   token_limit?: number;             // Input token limit (user sets effective limit)
   max_output_tokens?: number;       // Output token limit (API-enforced)
   thinking_budget?: number;         // Thinking token budget: 0 = disabled, N = enable with N tokens, undefined = don't send
+  temperature_disabled?: boolean;   // Set true for models that reject temperature (e.g. Anthropic extended-thinking models)
   total_calls?: number;             // Usage counter
   total_tokens_in?: number;         // Usage counter
   total_tokens_out?: number;        // Usage counter

package/src/core/utils/identifier-utils.ts

@@ -1,4 +1,5 @@
 import type { PersonIdentifier } from "../types/data-items.js";
+import type { PersonaEntity } from "../types/entities.js";
 import type { StateManager } from "../state-manager.js";
 import { BUILT_IN_IDENTIFIER_TYPES } from "../constants/built-in-identifier-types.js";
 
@@ -29,12 +30,12 @@ export function normalizeIdentifierType(llmType: string, state: StateManager): s
 
 export function sanitizeEiPersonaIdentifiers(
   identifiers: PersonIdentifier[],
-  state: StateManager
+  personas: PersonaEntity[]
 ): PersonIdentifier[] {
   return identifiers.map(id => {
     if (id.type !== 'Ei Persona' && id.type !== 'AI Persona') return id;
     if (UUID_REGEX.test(id.value)) return { ...id, type: 'Ei Persona' };
-    const matched = state.persona_getAll().find(p =>
+    const matched = personas.find(p =>
       p.display_name === id.value || p.aliases?.includes(id.value)
     );
     if (matched) return { ...id, type: 'Ei Persona', value: matched.id };

package/src/integrations/pi/importer.ts

@@ -20,11 +20,16 @@ import {
   type IPiReader,
 } from "./types.js";
 import { MIN_SESSION_AGE_MS, TWELVE_HOURS_MS } from "../constants.js";
+import {
+  ensureAgentPersona,
+  resolveCanonicalAgent,
+} from "../../core/personas/opencode-agent.js";
 
 export interface PiImportResult {
   sessionsProcessed: number;
   messagesImported: number;
   personaCreated: boolean;
+  personasCreated: string[];
   extractionScansQueued: number;
 }
 
@@ -121,6 +126,7 @@ export async function importPiSessions(options: PiImporterOptions): Promise<PiIm
     sessionsProcessed: 0,
     messagesImported: 0,
     personaCreated: false,
+    personasCreated: [],
     extractionScansQueued: 0,
   };
 
@@ -167,56 +173,142 @@ export async function importPiSessions(options: PiImporterOptions): Promise<PiIm
 
   if (signal?.aborted) return result;
 
-  const personaExistedBefore = stateManager.persona_getByName(PI_PERSONA_NAME) !== null;
-  const persona = ensurePiPersona(stateManager, eiInterface);
-  result.personaCreated = !personaExistedBefore;
-
-  const existingMsgs = stateManager.messages_get(persona.id);
-  const externalIds = existingMsgs.filter((m) => m.external === true).map((m) => m.id);
-  if (externalIds.length > 0) {
-    stateManager.messages_remove(persona.id, externalIds);
-  }
-
-  const cutoffIso = processedSessions[targetSession.id] ?? null;
-  const cutoffMs = cutoffIso ? new Date(cutoffIso).getTime() : null;
-  const toAnalyze: Message[] = [];
-
-  for (const msg of messages) {
-    const msgMs = new Date(msg.timestamp).getTime();
-    const isOld = cutoffMs !== null && msgMs < cutoffMs;
-    const eiMsg = isOld
-      ? convertToPreMarkedEiMessage(msg, targetSession.id, qualify)
-      : convertToEiMessage(msg, targetSession.id, qualify);
-
-    stateManager.messages_append(persona.id, eiMsg);
-    result.messagesImported++;
-    if (!isOld) toAnalyze.push(eiMsg);
-  }
-
-  stateManager.messages_sort(persona.id);
-  eiInterface?.onMessageAdded?.(persona.id);
-
-  if (toAnalyze.length > 0 && !signal?.aborted) {
-    const allInState = stateManager.messages_get(persona.id);
-    const analyzeIds = new Set(toAnalyze.map((m) => m.id));
-    const analyzeStartIndex = allInState.findIndex((m) => analyzeIds.has(m.id));
-    const contextMsgs = analyzeStartIndex > 0 ? allInState.slice(0, analyzeStartIndex) : [];
-
-    const context: ExtractionContext = {
-      personaId: persona.id,
-      channelDisplayName: persona.display_name,
-      messages_context: contextMsgs,
-      messages_analyze: toAnalyze,
-      sources: [`pi:${getMachineId()}:${targetSession.id}`],
-    };
-
-    queuePersonRewritePhase(stateManager);
-    queueTopicRewritePhase(stateManager);
-    queueAllScans(context, stateManager, {
-      extraction_model: human.settings?.pi?.extraction_model,
-      external_filter: "only",
-    });
-    result.extractionScansQueued += 4;
+  const hasAgentAttribution = messages.some((m) => m.agent != null);
+
+  if (!hasAgentAttribution) {
+    // ─── Single-persona path (vanilla Pi / OMP without active agent) ────────
+    const personaExistedBefore = stateManager.persona_getByName(PI_PERSONA_NAME) !== null;
+    const persona = ensurePiPersona(stateManager, eiInterface);
+    result.personaCreated = !personaExistedBefore;
+
+    const existingMsgs = stateManager.messages_get(persona.id);
+    const externalIds = existingMsgs.filter((m) => m.external === true).map((m) => m.id);
+    if (externalIds.length > 0) {
+      stateManager.messages_remove(persona.id, externalIds);
+    }
+
+    const cutoffIso = processedSessions[targetSession.id] ?? null;
+    const cutoffMs = cutoffIso ? new Date(cutoffIso).getTime() : null;
+    const toAnalyze: Message[] = [];
+
+    for (const msg of messages) {
+      const msgMs = new Date(msg.timestamp).getTime();
+      const isOld = cutoffMs !== null && msgMs < cutoffMs;
+      const eiMsg = isOld
+        ? convertToPreMarkedEiMessage(msg, targetSession.id, qualify)
+        : convertToEiMessage(msg, targetSession.id, qualify);
+
+      stateManager.messages_append(persona.id, eiMsg);
+      result.messagesImported++;
+      if (!isOld) toAnalyze.push(eiMsg);
+    }
+
+    stateManager.messages_sort(persona.id);
+    eiInterface?.onMessageAdded?.(persona.id);
+
+    if (toAnalyze.length > 0 && !signal?.aborted) {
+      const allInState = stateManager.messages_get(persona.id);
+      const analyzeIds = new Set(toAnalyze.map((m) => m.id));
+      const analyzeStartIndex = allInState.findIndex((m) => analyzeIds.has(m.id));
+      const contextMsgs = analyzeStartIndex > 0 ? allInState.slice(0, analyzeStartIndex) : [];
+
+      const context: ExtractionContext = {
+        personaId: persona.id,
+        channelDisplayName: persona.display_name,
+        messages_context: contextMsgs,
+        messages_analyze: toAnalyze,
+        sources: [`pi:${getMachineId()}:${targetSession.id}`],
+      };
+
+      queuePersonRewritePhase(stateManager);
+      queueTopicRewritePhase(stateManager);
+      queueAllScans(context, stateManager, {
+        extraction_model: human.settings?.pi?.extraction_model,
+        external_filter: "only",
+      });
+      result.extractionScansQueued += 4;
+    }
+  } else {
+    // ─── Multi-agent path (OMP sessions with agent attribution) ─────────────
+    const byPersonaId = new Map<string, { persona: NonNullable<ReturnType<typeof stateManager.persona_getByName>>; msgs: typeof messages; agentName: string }>();
+
+    for (const msg of messages) {
+      const agentName = msg.agent ?? PI_PERSONA_NAME;
+      let persona = stateManager.persona_getByName(agentName);
+      if (!persona) {
+        const { canonical } = resolveCanonicalAgent(agentName);
+        persona = stateManager.persona_getByName(canonical);
+      }
+      if (!persona) {
+        persona = await ensureAgentPersona(agentName, {
+          stateManager,
+          interface: eiInterface,
+          reader: undefined,
+        });
+        result.personasCreated.push(agentName);
+      }
+      const bucket = byPersonaId.get(persona.id);
+      if (bucket) {
+        bucket.msgs.push(msg);
+      } else {
+        byPersonaId.set(persona.id, { persona, msgs: [msg], agentName });
+      }
+    }
+
+    const cutoffIso = processedSessions[targetSession.id] ?? null;
+    const cutoffMs = cutoffIso ? new Date(cutoffIso).getTime() : null;
+    let anyPersonaHasChanges = false;
+
+    for (const [, { persona, msgs: agentMsgs }] of byPersonaId) {
+      const existingMsgs = stateManager.messages_get(persona.id);
+      const externalIds = existingMsgs.filter((m) => m.external === true).map((m) => m.id);
+      if (externalIds.length > 0) {
+        stateManager.messages_remove(persona.id, externalIds);
+      }
+
+      const toAnalyze: Message[] = [];
+      for (const msg of agentMsgs) {
+        const msgMs = new Date(msg.timestamp).getTime();
+        const isOld = cutoffMs !== null && msgMs < cutoffMs;
+        const eiMsg = isOld
+          ? convertToPreMarkedEiMessage(msg, targetSession.id, qualify)
+          : convertToEiMessage(msg, targetSession.id, qualify);
+
+        stateManager.messages_append(persona.id, eiMsg);
+        result.messagesImported++;
+        if (!isOld) toAnalyze.push(eiMsg);
+      }
+
+      stateManager.messages_sort(persona.id);
+      eiInterface?.onMessageAdded?.(persona.id);
+
+      if (toAnalyze.length > 0 && !signal?.aborted) {
+        const allInState = stateManager.messages_get(persona.id);
+        const analyzeIds = new Set(toAnalyze.map((m) => m.id));
+        const analyzeStartIndex = allInState.findIndex((m) => analyzeIds.has(m.id));
+        const contextMsgs = analyzeStartIndex > 0 ? allInState.slice(0, analyzeStartIndex) : [];
+
+        const context: ExtractionContext = {
+          personaId: persona.id,
+          channelDisplayName: persona.display_name,
+          messages_context: contextMsgs,
+          messages_analyze: toAnalyze,
+          sources: [`pi:${getMachineId()}:${targetSession.id}`],
+        };
+
+        anyPersonaHasChanges = true;
+        queueAllScans(context, stateManager, {
+          extraction_model: human.settings?.pi?.extraction_model,
+          external_filter: "only",
+        });
+        result.extractionScansQueued += 4;
+      }
+    }
+
+    if (anyPersonaHasChanges && !signal?.aborted) {
+      queuePersonRewritePhase(stateManager);
+      queueTopicRewritePhase(stateManager);
+    }
   }
 
   result.sessionsProcessed = 1;

package/src/integrations/pi/reader.ts

@@ -199,6 +199,7 @@ export class PiReader implements IPiReader {
         role,
         content,
         timestamp: ts ?? new Date(0).toISOString(),
+        agent: entry.agent as string | undefined,
       });
     }
 

package/src/integrations/pi/types.ts

@@ -49,6 +49,8 @@ export interface PiMessageEntry {
   id: string;
   parentId?: string;
   timestamp: string;
+  /** Active agent definition name, present only for OMP sessions. Mirrors the `agent` field on OpenCode message rows. */
+  agent?: string;
   message: PiMessagePayload;
   [key: string]: unknown;
 }
@@ -112,6 +114,8 @@ export interface PiMessage {
   role: "user" | "assistant";
   content: string;
   timestamp: string;
+  /** Active agent definition name when this message was recorded; undefined for vanilla Pi or OMP without an active agent. */
+  agent?: string;
 }
 
 // ============================================================================

package/src/storage/file-lock.ts

@@ -0,0 +1,120 @@
+/**
+ * File-based advisory locking + atomic writes, shared by any Storage
+ * implementation (and CLI tooling) that needs to serialize writes to a
+ * JSON file on disk without a database.
+ *
+ * Extracted from tui/src/storage/file.ts so the CLI's corrections.json
+ * writer/drainer can use identical lock semantics instead of forking a
+ * second implementation.
+ *
+ * fs/promises is imported dynamically per-function, not statically at
+ * module scope: this module is transitively imported by src/core/corrections.ts
+ * -> src/core/processor.ts, which Web's Vite build bundles for the browser.
+ * A static `import { readFile } from "fs/promises"` makes rollup try to
+ * resolve named exports against Vite's browser-externalized stub, which
+ * has none — that's a hard build failure, not a runtime one (same pattern
+ * already used in src/cli.ts and src/cli/install.ts for this exact reason).
+ */
+
+const LOCK_TIMEOUT_MS = 5000;
+const LOCK_RETRY_DELAY_MS = 50;
+
+// Plain executor form, not Promise.withResolvers — this module runs on
+// whatever Node the CLI/TUI ships with, and withResolvers only landed in
+// Node 22. No behavior difference, just broader runtime compatibility.
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function getLockPath(filePath: string): string {
+  return `${filePath}.lock`;
+}
+
+/**
+ * Acquire an advisory lock on filePath. Stale locks (older than
+ * LOCK_TIMEOUT_MS) are broken automatically. Returns false if the lock
+ * could not be acquired within LOCK_TIMEOUT_MS.
+ */
+export async function acquireLock(filePath: string): Promise<boolean> {
+  const { readFile, writeFile, unlink } = await import(/* @vite-ignore */ "fs/promises");
+  const lockPath = getLockPath(filePath);
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < LOCK_TIMEOUT_MS) {
+    // readFile throws ENOENT when the lock is absent — treated the same as
+    // "lock vanished mid-read" below: proceed straight to acquire.
+    let lockContent: string | null = null;
+    try {
+      lockContent = await readFile(lockPath, "utf-8");
+    } catch {
+      lockContent = null;
+    }
+
+    if (lockContent !== null) {
+      const lockTime = parseInt(lockContent, 10);
+      if (!isNaN(lockTime) && Date.now() - lockTime > LOCK_TIMEOUT_MS) {
+        try {
+          await unlink(lockPath);
+        } catch {}
+      } else {
+        await delay(LOCK_RETRY_DELAY_MS);
+        continue;
+      }
+    }
+
+    try {
+      // "wx" = exclusive create, fails with EEXIST if the path already
+      // exists. Without this flag, two callers that both observed the lock
+      // as absent (the check above) could both reach this writeFile and
+      // both succeed — writeFile has no atomicity of its own, it just
+      // overwrites. "wx" makes the write itself the atomic test-and-set:
+      // only one caller can win it, the other gets EEXIST and falls into
+      // the catch below to retry from the top of the loop.
+      await writeFile(lockPath, Date.now().toString(), { flag: "wx" });
+      return true;
+    } catch {
+      await delay(LOCK_RETRY_DELAY_MS);
+    }
+  }
+
+  return false;
+}
+
+export async function releaseLock(filePath: string): Promise<void> {
+  const { unlink } = await import(/* @vite-ignore */ "fs/promises");
+  const lockPath = getLockPath(filePath);
+  try {
+    await unlink(lockPath);
+  } catch {}
+}
+
+/**
+ * Run fn() while holding filePath's advisory lock. Throws
+ * STORAGE_LOCK_TIMEOUT if the lock can't be acquired in time.
+ */
+export async function withLock<T>(filePath: string, fn: () => Promise<T>): Promise<T> {
+  const acquired = await acquireLock(filePath);
+  if (!acquired) {
+    throw new Error("STORAGE_LOCK_TIMEOUT: Could not acquire file lock");
+  }
+  try {
+    return await fn();
+  } finally {
+    await releaseLock(filePath);
+  }
+}
+
+/** Write content to filePath via temp-file + rename, so readers never see a partial write. */
+export async function atomicWrite(filePath: string, content: string): Promise<void> {
+  const { writeFile, rename, unlink } = await import(/* @vite-ignore */ "fs/promises");
+  const tempPath = `${filePath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
+  try {
+    await writeFile(tempPath, content);
+    await rename(tempPath, filePath);
+  } catch (e) {
+    try {
+      await unlink(tempPath);
+    } catch {}
+    throw e;
+  }
+}

package/tui/README.md

@@ -174,6 +174,8 @@ Rooms have three modes, set at creation time:
 | `/tools` | | Manage tool providers — enable/disable tools per persona |
 | `/auth <service>` | | Authenticate with an external service via OAuth. Supported: `spotify`, `slack` |
 
+> Disabling a tool provider hides its tools from `/details`' YAML editor, but doesn't revoke them — a persona's grants for a disabled provider's tools survive an unrelated `/details` edit and reappear once you re-enable the provider with `/tools` or `/provider`.
+
 ### Editor
 
 | Command | Aliases | Description |

package/tui/src/commands/provider.tsx

@@ -48,7 +48,7 @@ export async function openModelOverlay(ctx: Parameters<Command["execute"]>[1]):
   const models = await buildModelList(ctx);
 
   if (models.length === 0) {
-    ctx.showNotification("No models configured. Use /provider new to create one.", "info");
+    await createProviderViaEditor(ctx);
     return;
   }
 

package/tui/src/components/WelcomeOverlay.tsx

@@ -90,9 +90,9 @@ export function WelcomeOverlay(props: WelcomeOverlayProps) {
         <box visible={!hasAny()} flexDirection="column">
           <text fg="#dc322f">No LLM provider detected.</text>
           <text> </text>
-          <text fg="#93a1a1">Start LMStudio (port 1234) or Ollama (port 11434), or</text>
-          <text fg="#93a1a1">set one of: ANTHROPIC_API_KEY, OPENAI_API_KEY, GROQ_API_KEY,</text>
-          <text fg="#93a1a1">MISTRAL_API_KEY, GEMINI_API_KEY and restart.</text>
+          <text fg="#93a1a1">Use /provider new to configure one manually, or</text>
+          <text fg="#93a1a1">start LMStudio (port 1234) / Ollama (port 11434), or</text>
+          <text fg="#93a1a1">set ANTHROPIC_API_KEY, OPENAI_API_KEY, etc. and restart.</text>
         </box>
 
         <text> </text>