@tenex-chat/backend 0.9.5 → 0.9.7

package/src/services/compression/compression-utils.ts

@@ -1,3 +1,4 @@
+import type { ToolCallPart, ToolResultPart } from "ai";
 import type { CompiledMessage } from "@/agents/execution/MessageCompiler";
 import type { ConversationEntry } from "@/conversations/types";
 import type {
@@ -258,13 +259,20 @@ export function validateSegmentsForEntries(
       };
     }
 
-    // Check for gaps between segments
+    // Check for gaps between segments.
+    // Non-eventId entries (tool-calls, tool-results) between two segments are fine:
+    // applySegmentsToEntries keeps them as-is in the output between the two summaries.
+    // Only flag a gap when eventId-bearing entries sit between segments and would
+    // be left uncompressed while we expected the LLM to cover the full range.
     if (i > 0) {
       const prevSegment = segments[i - 1];
       const prevToIndex = rangeEntries.findIndex(
         (e) => e.eventId === prevSegment.toEventId
       );
-      if (fromIndex !== prevToIndex + 1) {
+      const hasEventIdInGap = rangeEntries
+        .slice(prevToIndex + 1, fromIndex)
+        .some((e) => !!e.eventId);
+      if (hasEventIdInGap) {
         return {
           valid: false,
           error: `Gap between segment ${i - 1} and ${i}`,
@@ -314,9 +322,11 @@ export function applySegments(
       currentIndex++;
     }
 
-    // Add compressed summary as system message
+    // Add compressed summary as user message
+    // NOTE: Cannot use "system" role here because Anthropic requires all system
+    // messages at the top of the prompt, not interleaved with user/assistant turns.
     result.push({
-      role: "system",
+      role: "user",
       content: `[Compressed history]\n${segment.compressed}`,
       eventId: `compressed-${segment.fromEventId}-${segment.toEventId}`,
     });
@@ -359,10 +369,12 @@ export function truncateSlidingWindow(
 
   const kept = messages.slice(-windowSize);
 
-  // Add a system message at the start indicating truncation
+  // Add a user message at the start indicating truncation
+  // NOTE: Cannot use "system" role because Anthropic requires all system
+  // messages at the top of the prompt, not interleaved with user/assistant turns.
   return [
     {
-      role: "system",
+      role: "user",
       content: `[Earlier messages truncated. Showing last ${windowSize} messages.]`,
       eventId: `truncated-${currentTimestamp}`,
     },
@@ -407,15 +419,16 @@ export function applySegmentsToEntries(
       currentIndex++;
     }
 
-    // Add compressed summary as system entry with explicit role
-    // CRITICAL: role field prevents deriveRole from misclassifying as "user"
+    // Add compressed summary as user entry with explicit role
+    // NOTE: Cannot use "system" role here because Anthropic requires all system
+    // messages at the top of the prompt, not interleaved with user/assistant turns.
     result.push({
       pubkey: "system",
       content: `[Compressed history]\n${segment.compressed}`,
       messageType: "text",
       eventId: `compressed-${segment.fromEventId}-${segment.toEventId}`,
       timestamp: segment.createdAt / 1000,
-      role: "system",
+      role: "user",
     });
 
     // Skip the compressed range
@@ -431,6 +444,18 @@ export function applySegmentsToEntries(
   return result;
 }
 
+/**
+ * Estimate the character count for a single conversation entry.
+ * Accounts for both text content and tool payloads (toolData).
+ */
+function estimateEntryChars(entry: ConversationEntry): number {
+  let chars = entry.content.length;
+  if (entry.toolData && entry.toolData.length > 0) {
+    chars += JSON.stringify(entry.toolData).length;
+  }
+  return chars;
+}
+
 /**
  * Estimate token count for conversation entries using rough heuristic (chars/4).
  * This is faster than actual tokenization and sufficient for compression decisions.
@@ -442,18 +467,35 @@ export function applySegmentsToEntries(
  * @returns Estimated token count
  */
 export function estimateTokensFromEntries(entries: ConversationEntry[]): number {
-  const totalChars = entries.reduce((sum, entry) => {
-    let entryChars = entry.content.length;
+  const totalChars = entries.reduce((sum, entry) => sum + estimateEntryChars(entry), 0);
+  return Math.ceil(totalChars / 4);
+}
+
+/**
+ * Compute how many trailing entries fit within a token budget.
+ * Walks entries backwards, accumulating estimated tokens, and stops when the budget is exhausted.
+ *
+ * @param entries - All conversation entries
+ * @param tokenBudget - Maximum tokens the trailing window should contain
+ * @returns Number of trailing entries that fit within the budget (minimum 1)
+ */
+export function computeTokenAwareWindowSize(
+  entries: ConversationEntry[],
+  tokenBudget: number
+): number {
+  let accumulatedTokens = 0;
+  let count = 0;
 
-    // Account for tool payloads (tool-call/tool-result)
-    if (entry.toolData && entry.toolData.length > 0) {
-      const toolDataSize = JSON.stringify(entry.toolData).length;
-      entryChars += toolDataSize;
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entryTokens = Math.ceil(estimateEntryChars(entries[i]) / 4);
+    if (accumulatedTokens + entryTokens > tokenBudget && count > 0) {
+      break;
     }
+    accumulatedTokens += entryTokens;
+    count++;
+  }
 
-    return sum + entryChars;
-  }, 0);
-  return Math.ceil(totalChars / 4);
+  return Math.max(1, count);
 }
 
 /**
@@ -521,11 +563,14 @@ export function truncateSlidingWindowEntries(
   const kept = entries.slice(-windowSize);
 
   // Add a synthetic entry indicating truncation
+  // NOTE: Explicit role: "user" because Anthropic requires all system
+  // messages at the top of the prompt, not interleaved with user/assistant turns.
   const truncationEntry: ConversationEntry = {
     pubkey: "system",
     content: `[Earlier messages truncated. Showing last ${windowSize} messages.]`,
     messageType: "text",
     timestamp: currentTimestamp / 1000,
+    role: "user",
   };
 
   return [truncationEntry, ...kept];
@@ -575,12 +620,58 @@ export function createFallbackSegmentForEntries(
     }
   }
 
+  // Ensure the boundary doesn't cut in the middle of a tool-call/tool-result pair.
+  // Collect tool-calls in [0, toEntry.index] that have no matching result in the same range.
+  const pendingCallIds = new Set<string>();
+  for (let i = 0; i <= toEntry.index; i++) {
+    const entry = entries[i];
+    if (entry.messageType === "tool-call" && entry.toolData) {
+      for (const part of entry.toolData as ToolCallPart[]) {
+        pendingCallIds.add(part.toolCallId);
+      }
+    } else if (entry.messageType === "tool-result" && entry.toolData) {
+      for (const part of entry.toolData as ToolResultPart[]) {
+        pendingCallIds.delete(part.toolCallId);
+      }
+    }
+  }
+
+  // If there are unresolved tool-calls, their results live just after the boundary.
+  // Extend the segment past those orphaned tool-results so they are not left dangling.
+  if (pendingCallIds.size > 0) {
+    let i = toEntry.index + 1;
+    while (i < entries.length) {
+      const entry = entries[i];
+      if (
+        entry.messageType === "tool-result" &&
+        entry.toolData &&
+        (entry.toolData as ToolResultPart[]).some((p) => pendingCallIds.has(p.toolCallId))
+      ) {
+        for (const p of entry.toolData as ToolResultPart[]) {
+          pendingCallIds.delete(p.toolCallId);
+        }
+        i++;
+      } else {
+        break;
+      }
+    }
+    // Find the next entry with an eventId at or after position i to use as the new boundary.
+    for (let j = i; j < entries.length; j++) {
+      if (entries[j].eventId) {
+        toEntry = { entry: entries[j], index: j };
+        break;
+      }
+    }
+    // If no eventId is found we keep the original toEntry; MessageBuilder will skip
+    // any remaining orphaned tool-results as a safety net.
+  }
+
   const toEventId = toEntry.entry.eventId!;
 
   return {
     fromEventId,
     toEventId,
-    compressed: `[Truncated ${truncateCount} earlier messages due to compression failure]`,
+    compressed: `[Truncated ${toEntry.index + 1} earlier messages due to compression failure]`,
     createdAt: Date.now(),
     model: "fallback-truncation",
   };

package/src/services/config/types.ts

@@ -192,8 +192,6 @@ export interface MetaModelVariant {
     description?: string;
     /** Optional additional system prompt to inject when this variant is active */
     systemPrompt?: string;
-    /** Priority tier for conflict resolution (higher number = higher priority) */
-    tier?: number;
 }
 
 /**
@@ -207,8 +205,6 @@ export interface MetaModelConfiguration {
     variants: Record<string, MetaModelVariant>;
     /** Default variant to use when no keyword matches */
     default: string;
-    /** Optional description shown in system prompt preamble */
-    description?: string;
 }
 
 /**
@@ -258,7 +254,6 @@ export const MetaModelVariantSchema = z.object({
     keywords: z.array(z.string()).optional(),
     description: z.string().optional(),
     systemPrompt: z.string().optional(),
-    tier: z.number().optional(),
 });
 
 /**
@@ -268,7 +263,6 @@ export const MetaModelConfigurationSchema = z.object({
     provider: z.literal("meta"),
     variants: z.record(z.string(), MetaModelVariantSchema),
     default: z.string(),
-    description: z.string().optional(),
 });
 
 /**

package/src/services/dispatch/AgentDispatchService.ts

@@ -92,6 +92,19 @@ export class AgentDispatchService {
                 error: formatAnyError(error),
                 eventId: event.id,
             });
+            logger.writeToWarnLog({
+                timestamp: new Date().toISOString(),
+                level: "error",
+                component: "AgentDispatchService",
+                message: "Failed to route incoming reply",
+                context: {
+                    eventId: event.id,
+                    eventKind: event.kind,
+                    pubkey: event.pubkey,
+                },
+                error: formatAnyError(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
         } finally {
             span.end();
         }
@@ -372,6 +385,46 @@ export class AgentDispatchService {
                     "ral.is_streaming": activeRal.isStreaming,
                 });
             }
+
+            // IMMEDIATE MARKER UPDATE: Update delegation markers in ConversationStore
+            // right away, BEFORE the debounce. This ensures that if the executor's
+            // supervision re-engages and recompiles messages during the debounce window,
+            // it sees "DELEGATION COMPLETED" instead of stale "DELEGATION IN PROGRESS".
+            // The debounce still handles re-execution triggering and clearCompletedDelegations.
+            if (activeRal) {
+                const completedDelegations = ralRegistry.getConversationCompletedDelegations(
+                    delegationTarget.agent.pubkey,
+                    delegationTarget.conversationId,
+                    activeRal.ralNumber
+                );
+
+                const parentStore = ConversationStore.get(delegationTarget.conversationId);
+                if (parentStore && completedDelegations.length > 0) {
+                    let markersUpdated = 0;
+                    for (const completion of completedDelegations) {
+                        const updated = parentStore.updateDelegationMarker(
+                            completion.delegationConversationId,
+                            {
+                                status: completion.status,
+                                completedAt: completion.completedAt,
+                                abortReason: completion.status === "aborted" ? completion.abortReason : undefined,
+                            }
+                        );
+                        if (updated) markersUpdated++;
+                    }
+
+                    if (markersUpdated > 0) {
+                        await parentStore.save();
+                    }
+
+                    span.addEvent("dispatch.markers_updated_before_debounce", {
+                        "ral.number": activeRal.ralNumber,
+                        "delegation.completed_count": completedDelegations.length,
+                        "markers.updated_count": markersUpdated,
+                    });
+                }
+            }
+
             const debounceKey = `${delegationTarget.agent.pubkey}:${delegationTarget.conversationId}`;
             const debounceSequence = await this.waitForDelegationDebounce(debounceKey, span);
             if (this.delegationDebounceSequence.get(debounceKey) !== debounceSequence) {
@@ -535,6 +588,19 @@ export class AgentDispatchService {
                 code: SpanStatusCode.ERROR,
                 message: (error as Error).message,
             });
+            logger.writeToWarnLog({
+                timestamp: new Date().toISOString(),
+                level: "error",
+                component: "AgentDispatchService",
+                message: "Delegation routing execution failed",
+                context: {
+                    agentSlug: delegationTarget.agent.slug,
+                    conversationId: delegationTarget.conversationId,
+                    triggerEventId: event.id,
+                },
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
             throw error;
         } finally {
             span.end();
@@ -705,6 +771,19 @@ export class AgentDispatchService {
                     code: SpanStatusCode.ERROR,
                     message: (error as Error).message,
                 });
+                logger.writeToWarnLog({
+                    timestamp: new Date().toISOString(),
+                    level: "error",
+                    component: "AgentDispatchService",
+                    message: "Agent execution failed during dispatch",
+                    context: {
+                        agentSlug: targetAgent.slug,
+                        conversationId,
+                        triggerEventId: event.id,
+                    },
+                    error: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined,
+                });
                 throw error;
             } finally {
                 agentSpan.end();

package/src/services/intervention/InterventionService.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { InterventionPublisher } from "@/nostr/InterventionPublisher";
+import { NDKKind } from "@/nostr/kinds";
 import { config } from "@/services/ConfigService";
 import { PubkeyService } from "@/services/PubkeyService";
 import { getTrustPubkeyService } from "@/services/trust-pubkeys/TrustPubkeyService";
@@ -76,7 +77,8 @@ interface NotifiedEntry {
 
 /**
  * Persisted state for InterventionService.
- * Stored in ~/.tenex/intervention_state_<projectId>.json (project-scoped)
+ * Stored in ~/.tenex/intervention_state_<stateScope>.json (project-scoped).
+ * For NIP-33 project coordinates, stateScope is the project's dTag.
  */
 interface InterventionState {
     pending: PendingIntervention[];
@@ -176,12 +178,70 @@ export class InterventionService {
 
     /**
      * Get the state file path for a given project.
-     * State files are scoped by project ID.
+     * State files are scoped by dTag when projectId is a NIP-33 coordinate.
      */
     private getStateFilePath(projectId: string): string {
+        const stateScope = this.getStateScope(projectId);
+        return path.join(this.configDir, `intervention_state_${stateScope}.json`);
+    }
+
+    /**
+     * Derive stable state scope from a project identifier.
+     * Project coordinates use format: "<kind>:<authorPubkey>:<dTag>".
+     */
+    private getStateScope(projectId: string): string {
+        const parts = projectId.split(":");
+        const isProjectCoordinate = parts.length >= 3 && parts[0] === String(NDKKind.Project);
+        if (!isProjectCoordinate) {
+            return projectId;
+        }
+
+        const dTag = parts.slice(2).join(":");
+        return dTag || projectId;
+    }
+
+    /**
+     * Legacy path used before dTag-scoped filenames.
+     * Returns null when projectId already represents the state scope.
+     */
+    private getLegacyStateFilePath(projectId: string): string | null {
+        const stateScope = this.getStateScope(projectId);
+        if (stateScope === projectId) {
+            return null;
+        }
         return path.join(this.configDir, `intervention_state_${projectId}.json`);
     }
 
+    /**
+     * Read state file from canonical location, with fallback to legacy path.
+     */
+    private async readStateFile(projectId: string): Promise<{ data: string; loadedFromLegacyPath: boolean } | null> {
+        const stateFilePath = this.getStateFilePath(projectId);
+        try {
+            const data = await fs.readFile(stateFilePath, "utf-8");
+            return { data, loadedFromLegacyPath: false };
+        } catch (error: unknown) {
+            if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) {
+                throw error;
+            }
+        }
+
+        const legacyStateFilePath = this.getLegacyStateFilePath(projectId);
+        if (!legacyStateFilePath) {
+            return null;
+        }
+
+        try {
+            const data = await fs.readFile(legacyStateFilePath, "utf-8");
+            return { data, loadedFromLegacyPath: true };
+        } catch (error: unknown) {
+            if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+                return null;
+            }
+            throw error;
+        }
+    }
+
     /**
      * Get the singleton instance of InterventionService.
      */
@@ -996,8 +1056,6 @@ export class InterventionService {
      * Load persisted state from disk for the given project.
      */
     private async loadState(projectId: string): Promise<void> {
-        const stateFilePath = this.getStateFilePath(projectId);
-
         // Cancel all active timers from the previous project before clearing state.
         // Without this, timers from a previous project continue running and fire
         // against the new project's data, causing duplicate notifications and
@@ -1014,7 +1072,15 @@ export class InterventionService {
         this.triggeringConversations.clear();
 
         try {
-            const data = await fs.readFile(stateFilePath, "utf-8");
+            const stateFile = await this.readStateFile(projectId);
+            if (!stateFile) {
+                logger.debug("No existing intervention state file, starting fresh", {
+                    projectId: projectId.substring(0, 12),
+                });
+                return;
+            }
+
+            const data = stateFile.data;
             const state = JSON.parse(data) as InterventionState;
 
             for (const pending of state.pending) {
@@ -1039,13 +1105,20 @@ export class InterventionService {
                 projectId: projectId.substring(0, 12),
                 pendingCount: this.pendingInterventions.size,
                 notifiedCount: this.notifiedConversations.size,
+                loadedFromLegacyPath: stateFile.loadedFromLegacyPath,
             });
 
             trace.getActiveSpan()?.addEvent("intervention.state_loaded", {
                 "intervention.project_id": projectId.substring(0, 12),
                 "intervention.pending_count": this.pendingInterventions.size,
                 "intervention.notified_count": this.notifiedConversations.size,
+                "intervention.loaded_from_legacy_path": stateFile.loadedFromLegacyPath,
             });
+
+            // Persist back using canonical (dTag-scoped) filename after legacy load.
+            if (stateFile.loadedFromLegacyPath) {
+                this.saveState();
+            }
         } catch (error: unknown) {
             if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
                 // No existing file, starting fresh - this is expected

package/src/services/nip46/Nip46SigningService.ts

@@ -89,7 +89,7 @@ export class Nip46SigningService {
     isEnabled(): boolean {
         try {
             const cfg = config.getConfig();
-            return cfg.nip46?.enabled === true;
+            return cfg.nip46?.enabled !== false;
         } catch {
             return false;
         }
@@ -233,6 +233,19 @@ export class Nip46SigningService {
                 durationMs,
             });
 
+            logger.writeToWarnLog({
+                timestamp: new Date().toISOString(),
+                level: "error",
+                component: "Nip46SigningService",
+                message: "NIP-46 signer connection failed",
+                context: {
+                    ownerPubkey: ownerPubkey.substring(0, 12),
+                    durationMs,
+                },
+                error: errorMsg,
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+
             this.signingLog.log({
                 op: "sign_error",
                 requestId,
@@ -430,6 +443,22 @@ export class Nip46SigningService {
             durationMs,
         });
 
+        logger.writeToWarnLog({
+            timestamp: new Date().toISOString(),
+            level: "error",
+            component: "Nip46SigningService",
+            message: `NIP-46 signing failed after ${maxRetries} retries`,
+            context: {
+                ownerPubkey: ownerPubkey.substring(0, 12),
+                eventKind: event.kind,
+                retries: maxRetries,
+                durationMs,
+                isTimeout: errorMsg.includes("timed out"),
+            },
+            error: errorMsg,
+            stack: lastError?.stack,
+        });
+
         return { outcome: "failed", reason: errorMsg };
     }
 

package/src/services/projects/ProjectContext.ts

@@ -101,9 +101,10 @@ export function resolveProjectManager(
             }
         }
 
-        throw new Error(
-            `Project Manager agent not found. PM agent (eventId: ${pmEventId}) not loaded in registry.`
-        );
+        logger.warn("PM agent designated in project tags not loaded in registry yet, falling through", {
+            pmEventId,
+            loadedEventIds: Array.from(agents.values()).map(a => a.eventId),
+        });
     }
 
     // Step 5: Fallback to first agent from project tags
@@ -121,9 +122,10 @@ export function resolveProjectManager(
             }
         }
 
-        throw new Error(
-            `Project Manager agent not found. First agent (eventId: ${pmEventId}) not loaded in registry.`
-        );
+        logger.warn("First agent from project tags not loaded in registry yet, falling through", {
+            pmEventId,
+            loadedEventIds: Array.from(agents.values()).map(a => a.eventId),
+        });
     }
 
     // Step 6: No agent tags in project, use first from registry if any exist