@tenex-chat/backend 0.9.4 → 0.9.6

package/dist/wrapper.js

@@ -0,0 +1,171 @@
+#!/usr/bin/env bun
+
+// src/wrapper.ts
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+function resolveEntryPoint() {
+  const srcIndex = path.join(__dirname, "index.ts");
+  if (existsSync(srcIndex)) {
+    return srcIndex;
+  }
+  const distIndex = path.join(__dirname, "index.js");
+  if (existsSync(distIndex)) {
+    return distIndex;
+  }
+  const parentSrcIndex = path.join(path.dirname(__dirname), "src", "index.ts");
+  if (existsSync(parentSrcIndex)) {
+    return parentSrcIndex;
+  }
+  const parentDistIndex = path.join(path.dirname(__dirname), "dist", "index.js");
+  if (existsSync(parentDistIndex)) {
+    return parentDistIndex;
+  }
+  return srcIndex;
+}
+var MIN_UPTIME_MS = 5e3;
+var MAX_CRASHES = 5;
+var CRASH_WINDOW_MS = 6e4;
+var DaemonWrapper = class {
+  child = null;
+  crashHistory = [];
+  startTime = 0;
+  isShuttingDown = false;
+  /**
+   * Start the daemon wrapper
+   */
+  async start(args2) {
+    console.log("[Wrapper] Starting TENEX daemon supervisor");
+    console.log("[Wrapper] Daemon arguments:", args2.join(" ") || "(none)");
+    this.setupSignalHandlers();
+    await this.runDaemonLoop(args2);
+  }
+  /**
+   * Setup signal handlers for the wrapper process
+   */
+  setupSignalHandlers() {
+    process.on("SIGHUP", () => {
+      if (this.child && this.child.pid) {
+        console.log("[Wrapper] SIGHUP received - forwarding to daemon");
+        this.child.kill("SIGHUP");
+      }
+    });
+    const handleTermination = (signal) => {
+      if (this.isShuttingDown) {
+        console.log(`[Wrapper] ${signal} received during shutdown - forcing exit`);
+        process.exit(1);
+      }
+      console.log(`[Wrapper] ${signal} received - shutting down`);
+      this.isShuttingDown = true;
+      if (this.child && this.child.pid) {
+        this.child.kill(signal === "SIGTERM" ? "SIGTERM" : "SIGINT");
+        setTimeout(() => {
+          if (this.child && this.child.pid) {
+            console.log("[Wrapper] Child still running after timeout - forcing kill");
+            this.child.kill("SIGKILL");
+          }
+          process.exit(1);
+        }, 3e4);
+      } else {
+        process.exit(0);
+      }
+    };
+    process.on("SIGTERM", () => handleTermination("SIGTERM"));
+    process.on("SIGINT", () => handleTermination("SIGINT"));
+  }
+  /**
+   * Main daemon loop - spawn daemon and respawn on clean exit
+   */
+  async runDaemonLoop(args2) {
+    while (!this.isShuttingDown) {
+      if (this.isInCrashLoop()) {
+        console.error("[Wrapper] Crash loop detected - too many crashes in short period");
+        console.error(`[Wrapper] ${this.crashHistory.length} crashes in last ${CRASH_WINDOW_MS / 1e3}s`);
+        console.error("[Wrapper] Giving up - please check daemon logs");
+        process.exit(1);
+      }
+      this.startTime = Date.now();
+      const exitCode = await this.spawnDaemon(args2);
+      const uptime = Date.now() - this.startTime;
+      console.log(`[Wrapper] Daemon exited with code ${exitCode} after ${Math.round(uptime / 1e3)}s`);
+      if (this.isShuttingDown) {
+        console.log("[Wrapper] Wrapper shutting down, not respawning");
+        break;
+      }
+      if (exitCode === 0) {
+        console.log("[Wrapper] Daemon exited cleanly - respawning for graceful restart");
+        if (uptime >= MIN_UPTIME_MS) {
+          this.crashHistory = [];
+        }
+        await this.sleep(100);
+      } else {
+        console.error(`[Wrapper] Daemon crashed with exit code ${exitCode}`);
+        this.recordCrash();
+        const backoffMs = Math.min(1e3 * Math.pow(2, this.crashHistory.length - 1), 3e4);
+        console.log(`[Wrapper] Waiting ${backoffMs / 1e3}s before respawn...`);
+        await this.sleep(backoffMs);
+      }
+    }
+    console.log("[Wrapper] Exiting");
+    process.exit(0);
+  }
+  /**
+   * Spawn the daemon process and wait for it to exit
+   */
+  spawnDaemon(args2) {
+    return new Promise((resolve) => {
+      const indexPath = resolveEntryPoint();
+      const daemonArgs = [indexPath, "daemon", "--supervised", ...args2];
+      const runtimeBinary = indexPath.endsWith(".ts") ? process.env.TENEX_BUN_BIN || "bun" : process.execPath;
+      console.log(`[Wrapper] Spawning: ${runtimeBinary} ${daemonArgs.join(" ")}`);
+      this.child = spawn(runtimeBinary, daemonArgs, {
+        stdio: "inherit",
+        env: process.env
+      });
+      this.child.on("exit", (code) => {
+        this.child = null;
+        resolve(code ?? 1);
+      });
+      this.child.on("error", (error) => {
+        console.error("[Wrapper] Failed to spawn daemon:", error.message);
+        this.child = null;
+        resolve(1);
+      });
+    });
+  }
+  /**
+   * Record a crash for crash loop detection
+   */
+  recordCrash() {
+    const now = Date.now();
+    this.crashHistory.push({ timestamp: now });
+    this.crashHistory = this.crashHistory.filter(
+      (c) => now - c.timestamp < CRASH_WINDOW_MS
+    );
+  }
+  /**
+   * Check if we're in a crash loop
+   */
+  isInCrashLoop() {
+    const now = Date.now();
+    const recentCrashes = this.crashHistory.filter(
+      (c) => now - c.timestamp < CRASH_WINDOW_MS
+    );
+    return recentCrashes.length >= MAX_CRASHES;
+  }
+  /**
+   * Sleep for a given duration
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+var wrapper = new DaemonWrapper();
+var args = process.argv.slice(2);
+wrapper.start(args).catch((error) => {
+  console.error("[Wrapper] Fatal error:", error);
+  process.exit(1);
+});

package/package.json

@@ -1,17 +1,9 @@
 {
   "name": "@tenex-chat/backend",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "description": "TENEX Command Line Interface",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
   "bin": {
-    "tenex-backend": "./dist/tenex-backend-wrapper.cjs"
+    "tenex-backend": "./dist/daemon-wrapper.cjs"
   },
   "files": [
     "dist/**/*.js",
@@ -54,23 +46,23 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@ai-sdk/anthropic": "^3.0.46",
-    "@ai-sdk/openai": "^3.0.30",
+    "@ai-sdk/anthropic": "^3.0.58",
+    "@ai-sdk/openai": "^3.0.41",
     "@huggingface/transformers": "^3.8.1",
     "@lancedb/lancedb": "^0.26.2",
-    "@modelcontextprotocol/sdk": "^1.26.0",
-    "@nostr-dev-kit/ndk": "3.0.0",
-    "@openrouter/ai-sdk-provider": "^2.1.1",
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@nostr-dev-kit/ndk": "3.0.3",
+    "@openrouter/ai-sdk-provider": "^2.2.5",
     "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/auto-instrumentations-node": "^0.70.0",
-    "@opentelemetry/exporter-metrics-otlp-http": "^0.212.0",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.212.0",
-    "@opentelemetry/resources": "^2.3.0",
-    "@opentelemetry/sdk-node": "^0.212.0",
-    "@opentelemetry/sdk-trace-node": "^2.3.0",
-    "@opentelemetry/semantic-conventions": "^1.38.0",
-    "ai": "^6.0.65",
-    "ai-sdk-provider-claude-code": "*",
+    "@opentelemetry/auto-instrumentations-node": "^0.71.0",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.213.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.213.0",
+    "@opentelemetry/resources": "^2.6.0",
+    "@opentelemetry/sdk-node": "^0.213.0",
+    "@opentelemetry/sdk-trace-node": "^2.6.0",
+    "@opentelemetry/semantic-conventions": "^1.40.0",
+    "ai": "^6.0.116",
+    "ai-sdk-provider-claude-code": "3.4.3",
     "ai-sdk-provider-codex-app-server": "1.1.7",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
@@ -81,7 +73,7 @@
     "lodash": "^4.17.23",
     "node-cron": "^4.2.1",
     "node-html-markdown": "^2.0.0",
-    "nostr-tools": "^2.15.0",
+    "nostr-tools": "^2.23.3",
     "ollama-ai-provider-v2": "^3.0.3",
     "tseep": "^1.3.1",
     "zod": "^4.3.6"
@@ -90,10 +82,10 @@
     "@eslint/js": "^10.0.1",
     "esbuild": "^0.27.2",
     "esbuild-plugin-alias": "^0.2.1",
-    "eslint": "^10.0.0",
+    "eslint": "^10.0.3",
     "husky": "^9.1.7",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.53.0",
+    "typescript-eslint": "^8.56.1",
     "vitest": "^4.0.16"
   },
   "type": "module",

package/src/agents/AgentRegistry.ts

@@ -141,18 +141,20 @@ export class AgentRegistry {
             }
         }
 
-        // Check if critical agents failed
+        // Log failed agents but don't block project boot
         if (failedAgents.length > 0) {
-            // PM is the first agent in tags
             const pmEventId = agentEventIds[0];
             if (failedAgents.includes(pmEventId)) {
-                throw new Error(
-                    `Critical agent failed to load. Agent event ID ${pmEventId} could not be fetched. This might be due to network issues or the event not being available on the configured relays.`
+                logger.error(
+                    `PM agent (first in tags) failed to load — project will boot without a PM. Agent event ID ${pmEventId} could not be fetched. This might be due to network issues or the event not being available on the configured relays.`,
+                    { pmEventId, failedAgents }
+                );
+            } else {
+                logger.warn(
+                    `${failedAgents.length} agent(s) could not be installed but continuing with available agents`,
+                    { failedAgents }
                 );
             }
-            logger.warn(
-                `${failedAgents.length} agent(s) could not be installed but continuing with available agents`
-            );
         }
 
         // Load locally-associated agents from storage

package/src/agents/AgentStorage.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { StoredAgentData, ProjectScopedConfig, AgentDefaultConfig, AgentProjectConfig } from "@/agents/types";
+import type { AgentCategory } from "@/agents/role-categories";
 import type { MCPServerConfig } from "@/llm/providers/types";
 import {
     resolveEffectiveConfig,
@@ -100,6 +101,7 @@ export function createStoredAgent(config: {
     slug: string;
     name: string;
     role: string;
+    category?: AgentCategory;
     description?: string | null;
     instructions?: string | null;
     useCriteria?: string | null;
@@ -118,6 +120,7 @@ export function createStoredAgent(config: {
         slug: config.slug,
         name: config.name,
         role: config.role,
+        category: config.category,
         description: config.description ?? undefined,
         instructions: config.instructions ?? undefined,
         useCriteria: config.useCriteria ?? undefined,
@@ -658,7 +661,7 @@ export class AgentStorage {
 
     /**
      * Get agent by slug (uses index for O(1) lookup).
-     * Returns the agent matching this slug regardless of project.
+     * Returns the agent regardless of project assignment.
      * Use getAgentBySlugForProject() when you need project-scoped lookups.
      */
     async getAgentBySlug(slug: string): Promise<StoredAgent | null> {
@@ -1098,6 +1101,26 @@ export class AgentStorage {
         return true;
     }
 
+    /**
+     * Get all known agent pubkeys across all projects from the index.
+     * Returns pubkeys from the byProject index (source of truth for project associations).
+     *
+     * Used by the Daemon to seed the TrustPubkeyService global agent pubkeys set
+     * at startup, covering agents from not-yet-running projects.
+     */
+    async getAllKnownPubkeys(): Promise<Set<string>> {
+        if (!this.index) await this.loadIndex();
+        if (!this.index) return new Set();
+
+        const pubkeys = new Set<string>();
+        for (const projectPubkeys of Object.values(this.index.byProject)) {
+            for (const pubkey of projectPubkeys) {
+                pubkeys.add(pubkey);
+            }
+        }
+        return pubkeys;
+    }
+
     /**
      * Get all agents (for debugging/admin purposes)
      */

package/src/agents/agent-installer.ts

@@ -1,5 +1,6 @@
 import { agentStorage, createStoredAgent, type StoredAgent } from "@/agents/AgentStorage";
 import { AgentNotFoundError, AgentValidationError } from "@/agents/errors";
+import { isValidCategory, type AgentCategory } from "@/agents/role-categories";
 import { installAgentScripts } from "@/agents/script-installer";
 import { DEFAULT_AGENT_LLM_CONFIG } from "@/llm/constants";
 import { getNDK } from "@/nostr";
@@ -77,6 +78,7 @@ interface ParsedAgentEvent {
     slug: string;
     name: string;
     role: string;
+    category?: AgentCategory;
     description: string;
     instructions: string;
     useCriteria: string;
@@ -96,6 +98,8 @@ function parseAgentEvent(event: NDKEvent, slug: string): ParsedAgentEvent {
     const title = agentDef.title || "Unnamed Agent";
     const description = agentDef.description || "";
     const role = agentDef.role || "assistant";
+    const rawCategory = agentDef.category || undefined;
+    const category = rawCategory && isValidCategory(rawCategory) ? rawCategory : undefined;
     const instructions = agentDef.instructions || "";
     const useCriteria = agentDef.useCriteria || "";
 
@@ -117,6 +121,7 @@ function parseAgentEvent(event: NDKEvent, slug: string): ParsedAgentEvent {
         slug,
         name: title,
         role,
+        category,
         description,
         instructions,
         useCriteria,
@@ -191,6 +196,7 @@ export async function installAgentFromNostrEvent(
         slug: agentData.slug,
         name: agentData.name,
         role: agentData.role,
+        category: agentData.category,
         description: agentData.description,
         instructions: agentData.instructions,
         useCriteria: agentData.useCriteria,

package/src/agents/agent-loader.ts

@@ -2,6 +2,7 @@ import type { AgentRegistry } from "@/agents/AgentRegistry";
 import { agentStorage, type StoredAgent } from "@/agents/AgentStorage";
 import { installAgentFromNostr } from "@/agents/agent-installer";
 import { AgentSlugConflictError } from "@/agents/errors";
+import { resolveCategory } from "@/agents/role-categories";
 import { processAgentTools } from "@/agents/tool-normalization";
 import type { AgentInstance } from "@/agents/types";
 import { AgentMetadataStore } from "@/services/agents";
@@ -42,7 +43,10 @@ export function createAgentInstance(
     const effectiveTools = resolvedConfig.tools;
 
     // Process tools using pure functions
-    const validToolNames = processAgentTools(effectiveTools || [], storedAgent.slug);
+    const normalizedTools = processAgentTools(effectiveTools || [], storedAgent.slug);
+
+    // Resolve category for organizational purposes (no tool restrictions)
+    const resolvedCategory = resolveCategory(storedAgent.category);
 
     // Build agent-specific MCP config from stored mcpServers
     const agentMcpConfig: MCPConfig | undefined = storedAgent.mcpServers
@@ -57,11 +61,12 @@ export function createAgentInstance(
         pubkey,
         signer,
         role: storedAgent.role,
+        category: resolvedCategory,
         description: storedAgent.description,
         instructions: storedAgent.instructions,
         useCriteria: storedAgent.useCriteria,
         llmConfig: effectiveLLMConfig || DEFAULT_AGENT_LLM_CONFIG,
-        tools: validToolNames,
+        tools: normalizedTools,
         eventId: storedAgent.eventId,
         slug: storedAgent.slug,
         mcpServers: storedAgent.mcpServers,

package/src/agents/constants.ts

@@ -19,8 +19,16 @@ export const CORE_AGENT_TOOLS: ToolName[] = [
     // Conversation tools for project introspection
     "conversation_get", // All agents should access conversation details
     "conversation_list", // All agents should list conversations
-    // Unified search across all project knowledge
-    "search", // All agents should be able to search across reports, conversations, and lessons
+    // RAG tools for knowledge management
+    "rag_search", // All agents should be able to search across reports, conversations, and lessons
+    "rag_create_collection", // All agents should be able to create RAG collections
+    "rag_add_documents", // All agents should be able to add documents to collections
+    "rag_delete_collection", // All agents should be able to delete RAG collections
+    "rag_list_collections", // All agents should be able to list RAG collections
+    "rag_subscription_create", // All agents should be able to create RAG subscriptions
+    "rag_subscription_list", // All agents should be able to list RAG subscriptions
+    "rag_subscription_get", // All agents should be able to get RAG subscription details
+    "rag_subscription_delete", // All agents should be able to delete RAG subscriptions
     // Process control
     "kill", // All agents should be able to terminate processes
     // MCP resource reading and subscriptions (self-gating: only works if agent has MCP tools from that server)

package/src/agents/execution/AgentExecutor.ts

@@ -241,6 +241,23 @@ export class AgentExecutor {
                     }
                 }
 
+                logger.writeToWarnLog({
+                    timestamp: new Date().toISOString(),
+                    level: "error",
+                    component: "AgentExecutor",
+                    message: isCreditsError
+                        ? "Execution failed due to insufficient credits"
+                        : "Agent execution failed",
+                    context: {
+                        agentSlug: context.agent.slug,
+                        conversationId: conversation?.id?.substring(0, 12),
+                        isCreditsError,
+                        errorType: isCreditsError ? "insufficient_credits" : "execution_error",
+                    },
+                    error: errorMessage,
+                    stack: error instanceof Error ? error.stack : undefined,
+                });
+
                 logger.error(
                     isCreditsError
                         ? "[AgentExecutor] Execution failed due to insufficient credits"
@@ -320,6 +337,18 @@ export class AgentExecutor {
                 agent: context.agent.slug,
                 error: formatAnyError(streamError),
             });
+            logger.writeToWarnLog({
+                timestamp: new Date().toISOString(),
+                level: "error",
+                component: "AgentExecutor",
+                message: "LLM streaming execution failed",
+                context: {
+                    agentSlug: context.agent.slug,
+                    ralNumber,
+                },
+                error: formatAnyError(streamError),
+                stack: streamError instanceof Error ? streamError.stack : undefined,
+            });
             throw streamError;
         }
 
@@ -388,20 +417,18 @@ export class AgentExecutor {
             "outstanding.has_work": outstandingWork.hasWork,
             "outstanding.queued_injections": outstandingWork.details.queuedInjections,
             "outstanding.pending_delegations": outstandingWork.details.pendingDelegations,
-            "fix_applied": "uses hasOutstandingWork() to check both injections and delegations",
+            "outstanding.completed_delegations": outstandingWork.details.completedDelegations,
         });
 
-        // INVARIANT GUARD: If there's outstanding work (queued injections OR pending delegations),
-        // we should NOT finalize. The executor should continue to allow the work to be processed.
+        // INVARIANT GUARD: If there's outstanding work (queued injections, pending delegations,
+        // or completed delegations not yet consumed), we should NOT finalize.
         const hasMessageContent = completionEvent?.message && completionEvent.message.length > 0;
         if (!hasMessageContent && outstandingWork.hasWork) {
-            // This is the expected path when delegation results arrive via debounce.
-            // The executor returns undefined to allow the dispatch loop to continue
-            // and process the queued injections in the next iteration.
             trace.getActiveSpan()?.addEvent("executor.awaiting_outstanding_work", {
                 "ral.number": ralNumber,
                 "outstanding.queued_injections": outstandingWork.details.queuedInjections,
                 "outstanding.pending_delegations": outstandingWork.details.pendingDelegations,
+                "outstanding.completed_delegations": outstandingWork.details.completedDelegations,
                 "completion_event_exists": Boolean(completionEvent),
                 "scenario": "injection_debounce_await",
             });
@@ -410,6 +437,7 @@ export class AgentExecutor {
                 ralNumber,
                 queuedInjections: outstandingWork.details.queuedInjections,
                 pendingDelegations: outstandingWork.details.pendingDelegations,
+                completedDelegations: outstandingWork.details.completedDelegations,
             });
             return undefined;
         }
@@ -486,6 +514,7 @@ export class AgentExecutor {
             "outstanding.has_work": finalOutstandingWork.hasWork,
             "outstanding.queued_injections": finalOutstandingWork.details.queuedInjections,
             "outstanding.pending_delegations": finalOutstandingWork.details.pendingDelegations,
+            "outstanding.completed_delegations": finalOutstandingWork.details.completedDelegations,
         });
 
         let responseEvent: NDKEvent | undefined;

package/src/agents/execution/StreamCallbacks.ts

@@ -6,7 +6,6 @@
  */
 
 import { formatAnyError } from "@/lib/error-formatter";
-import { LLMService } from "@/llm/service";
 import { llmServiceFactory } from "@/llm/LLMServiceFactory";
 import { shortenConversationId } from "@/utils/conversation-id";
 import { config as configService } from "@/services/ConfigService";
@@ -14,7 +13,7 @@ import { RALRegistry } from "@/services/ral";
 import type { SkillData } from "@/services/skill";
 import { logger } from "@/utils/logger";
 import { SpanStatusCode, trace } from "@opentelemetry/api";
-import type { LanguageModel, ModelMessage } from "ai";
+import type { LanguageModel, ModelMessage, ProviderRegistryProvider } from "ai";
 
 const tracer = trace.getTracer("tenex.stream-callbacks");
 import { MessageCompiler } from "./MessageCompiler";
@@ -53,7 +52,11 @@ export interface StepData {
  */
 export interface PrepareStepConfig {
     context: FullRuntimeContext;
-    llmService: { provider: string; updateUsageFromSteps: (steps: StepData["steps"]) => void };
+    llmService: {
+        provider: string;
+        updateUsageFromSteps: (steps: StepData["steps"]) => void;
+        createLanguageModelFromRegistry: (provider: string, model: string, registry: ProviderRegistryProvider) => LanguageModel;
+    };
     messageCompiler: MessageCompiler;
     ephemeralMessages: Array<{ role: "user" | "system"; content: string }>;
     nudgeContent: string;
@@ -147,15 +150,25 @@ export function createPrepareStep(
                                 content: injection.content,
                             });
                         } else {
-                            conversationStore.addMessage({
-                                pubkey: context.triggeringEvent.pubkey,
-                                ral: ralNumber,
-                                content: injection.content,
-                                messageType: "text",
-                                targetedPubkeys: [context.agent.pubkey],
-                                senderPubkey: injection.senderPubkey,
-                                eventId: injection.eventId,
-                            });
+                            const relocated = injection.eventId
+                                ? conversationStore.relocateToEnd(injection.eventId, {
+                                      ral: ralNumber,
+                                      senderPubkey: injection.senderPubkey,
+                                      targetedPubkeys: [context.agent.pubkey],
+                                  })
+                                : false;
+
+                            if (!relocated) {
+                                conversationStore.addMessage({
+                                    pubkey: context.triggeringEvent.pubkey,
+                                    ral: ralNumber,
+                                    content: injection.content,
+                                    messageType: "text",
+                                    targetedPubkeys: [context.agent.pubkey],
+                                    senderPubkey: injection.senderPubkey,
+                                    eventId: injection.eventId,
+                                });
+                            }
                         }
                     }
 
@@ -259,7 +272,7 @@ export function createPrepareStep(
 
                             try {
                                 const registry = llmServiceFactory.getRegistry();
-                                const newModel = LLMService.createLanguageModelFromRegistry(
+                                const newModel = llmService.createLanguageModelFromRegistry(
                                     newLlmConfig.provider,
                                     newLlmConfig.model,
                                     registry
@@ -291,6 +304,19 @@ export function createPrepareStep(
                                     variant: currentVariant,
                                     config: resolution.configName,
                                 });
+                                logger.writeToWarnLog({
+                                    timestamp: new Date().toISOString(),
+                                    level: "error",
+                                    component: "StreamCallbacks",
+                                    message: "Failed to create new model for variant switch",
+                                    context: {
+                                        agent: context.agent.slug,
+                                        variant: currentVariant,
+                                        config: resolution.configName,
+                                    },
+                                    error: formatAnyError(modelError),
+                                    stack: modelError instanceof Error ? modelError.stack : undefined,
+                                });
                             }
                         }
                     }
@@ -302,6 +328,20 @@ export function createPrepareStep(
             } catch (error) {
                 span.recordException(error as Error);
                 span.setStatus({ code: SpanStatusCode.ERROR });
+                logger.writeToWarnLog({
+                    timestamp: new Date().toISOString(),
+                    level: "error",
+                    component: "StreamCallbacks",
+                    message: "LLM streaming prepareStep failed",
+                    context: {
+                        agent: context.agent.slug,
+                        conversationId: context.conversationId,
+                        stepNumber: step.stepNumber,
+                        ralNumber,
+                    },
+                    error: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined,
+                });
                 throw error;
             } finally {
                 span.end();