@stackmemoryai/stackmemory 0.5.57 → 0.5.59

package/dist/src/integrations/ralph/patterns/extended-coherence-sessions.js

@@ -0,0 +1,473 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { v4 as uuidv4 } from "uuid";
+import * as fs from "fs/promises";
+import * as path from "path";
+import { logger } from "../../../core/monitoring/logger.js";
+import { RalphStackMemoryBridge } from "../bridge/ralph-stackmemory-bridge.js";
+class ExtendedCoherenceManager {
+  activeSessions = /* @__PURE__ */ new Map();
+  baseDir;
+  monitoringInterval;
+  performanceHistory = /* @__PURE__ */ new Map();
+  constructor(baseDir = "./.coherence-sessions") {
+    this.baseDir = baseDir;
+  }
+  /**
+   * Initialize the coherence management system
+   */
+  async initialize() {
+    await fs.mkdir(this.baseDir, { recursive: true });
+    this.monitoringInterval = setInterval(
+      () => this.monitorActiveSessionsHealth(),
+      6e4
+      // Check every minute
+    );
+    logger.info("Extended Coherence Manager initialized", {
+      baseDir: this.baseDir,
+      monitoringEnabled: true
+    });
+  }
+  /**
+   * Start an extended coherence work session
+   */
+  async startCoherenceSession(agentConfig, taskConfig, sessionConfig) {
+    const sessionId = uuidv4();
+    const defaultConfig = this.generateConfigForComplexity(taskConfig.complexity);
+    const config = { ...defaultConfig, ...sessionConfig };
+    const session = {
+      id: sessionId,
+      agent: agentConfig,
+      task: {
+        ...taskConfig,
+        breakpoints: taskConfig.breakpoints || this.generateBreakpoints(taskConfig)
+      },
+      config,
+      state: {
+        status: "active",
+        currentPhase: "initialization",
+        completedMilestones: [],
+        lastCheckpoint: Date.now(),
+        interventionCount: 0,
+        refreshCount: 0
+      },
+      metrics: [],
+      interventions: []
+    };
+    this.activeSessions.set(sessionId, session);
+    await this.initializeSessionWorkspace(session);
+    await this.launchAgentSession(session);
+    logger.info("Extended coherence session started", {
+      sessionId,
+      agent: agentConfig.role,
+      estimatedDuration: taskConfig.estimatedDuration,
+      maxDuration: config.maxDuration
+    });
+    return sessionId;
+  }
+  /**
+   * Generate configuration optimized for task complexity
+   */
+  generateConfigForComplexity(complexity) {
+    const configs = {
+      low: {
+        maxDuration: 60,
+        // 1 hour
+        coherenceThreshold: 0.7,
+        checkpointInterval: 15,
+        // 15 minutes
+        refreshStrategy: "checkpoint",
+        enableMemoryPalace: false,
+        enableProgressTracking: true,
+        enableAutoRefresh: false,
+        enableHealthMonitoring: true
+      },
+      medium: {
+        maxDuration: 180,
+        // 3 hours
+        coherenceThreshold: 0.8,
+        checkpointInterval: 10,
+        // 10 minutes
+        refreshStrategy: "context_refresh",
+        enableMemoryPalace: true,
+        enableProgressTracking: true,
+        enableAutoRefresh: true,
+        enableHealthMonitoring: true
+      },
+      high: {
+        maxDuration: 360,
+        // 6 hours
+        coherenceThreshold: 0.85,
+        checkpointInterval: 8,
+        // 8 minutes
+        refreshStrategy: "context_refresh",
+        enableMemoryPalace: true,
+        enableProgressTracking: true,
+        enableAutoRefresh: true,
+        enableHealthMonitoring: true
+      },
+      very_high: {
+        maxDuration: 720,
+        // 12 hours
+        coherenceThreshold: 0.9,
+        checkpointInterval: 5,
+        // 5 minutes
+        refreshStrategy: "full_restart",
+        enableMemoryPalace: true,
+        enableProgressTracking: true,
+        enableAutoRefresh: true,
+        enableHealthMonitoring: true
+      }
+    };
+    return configs[complexity];
+  }
+  /**
+   * Monitor active sessions for coherence degradation
+   */
+  async monitorActiveSessionsHealth() {
+    for (const [sessionId, session] of this.activeSessions) {
+      if (session.state.status === "active") {
+        await this.assessSessionCoherence(session);
+      }
+    }
+  }
+  /**
+   * Assess session coherence and intervene if necessary
+   */
+  async assessSessionCoherence(session) {
+    const metrics = await this.calculateCoherenceMetrics(session);
+    session.metrics.push(metrics);
+    if (session.metrics.length > 10) {
+      session.metrics.shift();
+    }
+    const overallCoherence = this.calculateOverallCoherence(metrics);
+    logger.debug("Session coherence assessment", {
+      sessionId: session.id,
+      coherence: overallCoherence,
+      threshold: session.config.coherenceThreshold,
+      duration: metrics.duration
+    });
+    if (overallCoherence < session.config.coherenceThreshold) {
+      await this.interventeInSession(session, "coherence_degradation", overallCoherence);
+    }
+    const timeSinceCheckpoint = Date.now() - session.state.lastCheckpoint;
+    const checkpointDue = timeSinceCheckpoint > session.config.checkpointInterval * 60 * 1e3;
+    if (checkpointDue) {
+      await this.checkpointSession(session);
+    }
+  }
+  /**
+   * Calculate comprehensive coherence metrics
+   */
+  async calculateCoherenceMetrics(session) {
+    const now = Date.now();
+    const duration = (now - session.metrics[0]?.startTime || now) / (1e3 * 60);
+    const recentOutputs = await this.getRecentAgentOutputs(session);
+    const outputQuality = this.assessOutputQuality(recentOutputs);
+    const contextRetention = this.assessContextRetention(recentOutputs, session.task);
+    const taskRelevance = this.assessTaskRelevance(recentOutputs, session.task);
+    const repetitionRate = this.calculateRepetitionRate(recentOutputs);
+    const divergenceRate = this.calculateDivergenceRate(recentOutputs, session.task);
+    const errorRate = this.calculateErrorRate(recentOutputs);
+    const progressRate = this.calculateProgressRate(session);
+    return {
+      sessionId: session.id,
+      startTime: session.metrics[0]?.startTime || now,
+      currentTime: now,
+      duration,
+      outputQuality,
+      contextRetention,
+      taskRelevance,
+      progressRate,
+      repetitionRate,
+      divergenceRate,
+      errorRate,
+      memoryUsage: await this.getMemoryUsage(session),
+      contextWindowUsage: await this.getContextWindowUsage(session),
+      stateCheckpoints: session.interventions.filter((i) => i.type === "checkpoint").length
+    };
+  }
+  /**
+   * Calculate overall coherence score
+   */
+  calculateOverallCoherence(metrics) {
+    const weights = {
+      outputQuality: 0.3,
+      contextRetention: 0.25,
+      taskRelevance: 0.25,
+      repetitionPenalty: 0.1,
+      // penalty for repetition
+      divergencePenalty: 0.1
+      // penalty for divergence
+    };
+    const baseScore = metrics.outputQuality * weights.outputQuality + metrics.contextRetention * weights.contextRetention + metrics.taskRelevance * weights.taskRelevance;
+    const penalties = metrics.repetitionRate * weights.repetitionPenalty + metrics.divergenceRate * weights.divergencePenalty;
+    return Math.max(0, baseScore - penalties);
+  }
+  /**
+   * Intervene in a session to restore coherence
+   */
+  async interventeInSession(session, reason, currentCoherence) {
+    logger.warn("Intervening in session due to coherence degradation", {
+      sessionId: session.id,
+      reason,
+      currentCoherence,
+      interventionCount: session.state.interventionCount
+    });
+    const intervention = {
+      timestamp: Date.now(),
+      type: session.config.refreshStrategy,
+      reason,
+      effectiveness: 0
+      // will be calculated later
+    };
+    switch (session.config.refreshStrategy) {
+      case "checkpoint":
+        await this.checkpointSession(session);
+        break;
+      case "context_refresh":
+        await this.refreshSessionContext(session);
+        break;
+      case "full_restart":
+        await this.restartSession(session);
+        break;
+      default:
+        await this.provideGuidance(session, reason);
+        intervention.type = "guidance";
+    }
+    session.interventions.push(intervention);
+    session.state.interventionCount++;
+    const previousStatus = session.state.status;
+    session.state.status = "degraded";
+    setTimeout(async () => {
+      const newMetrics = await this.calculateCoherenceMetrics(session);
+      const newCoherence = this.calculateOverallCoherence(newMetrics);
+      intervention.effectiveness = Math.max(0, newCoherence - currentCoherence);
+      if (newCoherence > session.config.coherenceThreshold) {
+        session.state.status = "active";
+        logger.info("Session coherence restored", {
+          sessionId: session.id,
+          newCoherence,
+          effectiveness: intervention.effectiveness
+        });
+      }
+    }, 12e4);
+  }
+  /**
+   * Create a checkpoint of session state
+   */
+  async checkpointSession(session) {
+    const checkpointPath = path.join(
+      this.baseDir,
+      session.id,
+      `checkpoint-${Date.now()}.json`
+    );
+    const checkpointData = {
+      timestamp: Date.now(),
+      state: session.state,
+      recentMetrics: session.metrics.slice(-3),
+      currentPhase: session.state.currentPhase,
+      completedMilestones: session.state.completedMilestones,
+      // Include recent agent context
+      contextSummary: await this.generateContextSummary(session)
+    };
+    await fs.writeFile(checkpointPath, JSON.stringify(checkpointData, null, 2));
+    session.state.lastCheckpoint = Date.now();
+    logger.info("Session checkpoint created", {
+      sessionId: session.id,
+      checkpointPath
+    });
+  }
+  /**
+   * Refresh session context to restore coherence
+   */
+  async refreshSessionContext(session) {
+    logger.info("Refreshing session context", { sessionId: session.id });
+    const refreshPrompt = await this.generateContextRefreshPrompt(session);
+    await this.applyContextRefresh(session, refreshPrompt);
+    session.state.refreshCount++;
+  }
+  /**
+   * Restart session from last good checkpoint
+   */
+  async restartSession(session) {
+    logger.info("Restarting session from checkpoint", { sessionId: session.id });
+    const checkpoint = await this.loadLatestCheckpoint(session);
+    if (checkpoint) {
+      session.state = { ...checkpoint.state };
+      await this.restartAgentFromCheckpoint(session, checkpoint);
+    } else {
+      await this.restartAgentFromBeginning(session);
+    }
+  }
+  /**
+   * Initialize workspace for a coherence session
+   */
+  async initializeSessionWorkspace(session) {
+    const sessionDir = path.join(this.baseDir, session.id);
+    await fs.mkdir(sessionDir, { recursive: true });
+    const manifest = {
+      sessionId: session.id,
+      agent: session.agent,
+      task: session.task,
+      config: session.config,
+      createdAt: Date.now()
+    };
+    await fs.writeFile(
+      path.join(sessionDir, "manifest.json"),
+      JSON.stringify(manifest, null, 2)
+    );
+  }
+  /**
+   * Launch the actual agent work session
+   */
+  async launchAgentSession(session) {
+    const sessionDir = path.join(this.baseDir, session.id);
+    const ralph = new RalphStackMemoryBridge({
+      baseDir: sessionDir,
+      maxIterations: Math.ceil(session.config.maxDuration / 5),
+      // ~5 min per iteration
+      useStackMemory: true
+    });
+    await ralph.initialize({
+      task: this.buildExtendedCoherencePrompt(session),
+      criteria: session.task.breakpoints.join("\n")
+    });
+    ralph.run().catch((error) => {
+      logger.error("Extended coherence session failed", {
+        sessionId: session.id,
+        error: error.message
+      });
+      session.state.status = "failed";
+    });
+  }
+  /**
+   * Build prompt optimized for extended coherence
+   */
+  buildExtendedCoherencePrompt(session) {
+    return `
+# EXTENDED COHERENCE WORK SESSION
+
+## Your Mission
+${session.task.description}
+
+## Session Parameters
+- Estimated Duration: ${session.task.estimatedDuration} minutes
+- Maximum Duration: ${session.config.maxDuration} minutes  
+- Coherence Threshold: ${session.config.coherenceThreshold * 100}%
+
+## Coherence Guidelines
+1. **Maintain Focus**: Stay on task throughout the entire session
+2. **Track Progress**: Document incremental progress at each step
+3. **Context Awareness**: Reference previous work and maintain consistency
+4. **Quality Control**: Regularly assess your output quality
+5. **Milestone Reporting**: Report when you reach natural breakpoints
+
+## Breakpoints & Milestones
+${session.task.breakpoints.map((bp, i) => `${i + 1}. ${bp}`).join("\n")}
+
+## Extended Session Strategy
+- Take regular checkpoint breaks (every ${session.config.checkpointInterval} minutes)
+- Summarize your progress regularly
+- Ask for context refresh if you feel you're losing focus
+- Maintain awareness of the overall project goal
+- Break complex tasks into smaller, manageable chunks
+
+## Memory Palace (if enabled)
+${session.config.enableMemoryPalace ? `
+Use structured memory organization:
+- **Project Context**: Overall goals and requirements
+- **Current Status**: What's been completed and what's next
+- **Working Memory**: Current task details and immediate context
+- **Reference Memory**: Important patterns, decisions, and learnings
+` : ""}
+
+## Success Criteria
+- Complete the task within the allocated time
+- Maintain high output quality throughout
+- Document progress and decisions clearly
+- Stay coherent and focused for the entire session
+
+Begin your extended coherence work session now.
+    `;
+  }
+  // Placeholder implementations for helper methods
+  async getRecentAgentOutputs(session) {
+    return [];
+  }
+  assessOutputQuality(outputs) {
+    return 0.8;
+  }
+  assessContextRetention(outputs, task) {
+    return 0.7;
+  }
+  assessTaskRelevance(outputs, task) {
+    return 0.9;
+  }
+  calculateRepetitionRate(outputs) {
+    return 0.1;
+  }
+  calculateDivergenceRate(outputs, task) {
+    return 0.05;
+  }
+  calculateErrorRate(outputs) {
+    return 0.02;
+  }
+  calculateProgressRate(session) {
+    return 2.5;
+  }
+  async getMemoryUsage(session) {
+    return 150;
+  }
+  async getContextWindowUsage(session) {
+    return 65;
+  }
+  generateBreakpoints(taskConfig) {
+    return [
+      "Initial analysis complete",
+      "Core implementation finished",
+      "Testing phase complete",
+      "Final review and cleanup done"
+    ];
+  }
+  async generateContextSummary(session) {
+    return `Session ${session.id} context summary`;
+  }
+  async generateContextRefreshPrompt(session) {
+    return "Context refresh prompt";
+  }
+  async applyContextRefresh(session, prompt) {
+  }
+  async loadLatestCheckpoint(session) {
+    return null;
+  }
+  async restartAgentFromCheckpoint(session, checkpoint) {
+  }
+  async restartAgentFromBeginning(session) {
+  }
+  async provideGuidance(session, reason) {
+  }
+  /**
+   * Get extended coherence capabilities
+   */
+  getCoherenceCapabilities() {
+    const activeSessions = Array.from(this.activeSessions.values());
+    return {
+      maxSessionDuration: Math.max(...activeSessions.map((s) => s.config.maxDuration)),
+      activeSessionCount: activeSessions.filter((s) => s.state.status === "active").length,
+      averageCoherence: activeSessions.reduce((sum, s) => {
+        const recent = s.metrics.slice(-1)[0];
+        return sum + (recent ? this.calculateOverallCoherence(recent) : 0);
+      }, 0) / activeSessions.length,
+      totalInterventions: activeSessions.reduce((sum, s) => sum + s.interventions.length, 0)
+    };
+  }
+}
+var extended_coherence_sessions_default = ExtendedCoherenceManager;
+export {
+  ExtendedCoherenceManager,
+  extended_coherence_sessions_default as default
+};
+//# sourceMappingURL=extended-coherence-sessions.js.map

package/dist/src/integrations/ralph/patterns/extended-coherence-sessions.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/integrations/ralph/patterns/extended-coherence-sessions.ts"],
+  "sourcesContent": ["/**\n * Extended Coherence Work Sessions Implementation\n * \n * Enables agents to work continuously for hours without performance degradation.\n * Maintains contextual awareness and high-quality output over extended periods.\n * \n * Addresses the challenge of AI agents losing coherence after short time periods.\n */\n\nimport { v4 as uuidv4 } from 'uuid';\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { logger } from '../../../core/monitoring/logger.js';\nimport { RalphStackMemoryBridge } from '../bridge/ralph-stackmemory-bridge.js';\n\nexport interface CoherenceMetrics {\n  sessionId: string;\n  startTime: number;\n  currentTime: number;\n  duration: number; // in minutes\n  \n  // Performance indicators\n  outputQuality: number; // 0-1 scale\n  contextRetention: number; // 0-1 scale\n  taskRelevance: number; // 0-1 scale\n  progressRate: number; // tasks/hour\n  \n  // Coherence indicators\n  repetitionRate: number; // how often agent repeats itself\n  divergenceRate: number; // how often agent goes off-topic\n  errorRate: number; // errors per iteration\n  \n  // State management\n  memoryUsage: number; // MB\n  contextWindowUsage: number; // percentage\n  stateCheckpoints: number; // number of saves\n}\n\nexport interface CoherenceSession {\n  id: string;\n  agent: {\n    id: string;\n    role: string;\n    model: string;\n  };\n  task: {\n    description: string;\n    complexity: 'low' | 'medium' | 'high' | 'very_high';\n    estimatedDuration: number; // minutes\n    breakpoints: string[]; // natural stopping points\n  };\n  \n  // Session configuration\n  config: {\n    maxDuration: number; // minutes\n    coherenceThreshold: number; // 0-1, below which to intervene\n    checkpointInterval: number; // minutes\n    refreshStrategy: 'none' | 'checkpoint' | 'context_refresh' | 'full_restart';\n    \n    // Advanced coherence features\n    enableMemoryPalace: boolean; // structured memory system\n    enableProgressTracking: boolean; // track incremental progress\n    enableAutoRefresh: boolean; // automatic context refresh\n    enableHealthMonitoring: boolean; // monitor agent health\n  };\n  \n  // Runtime state\n  state: {\n    status: 'active' | 'paused' | 'degraded' | 'completed' | 'failed';\n    currentPhase: string;\n    completedMilestones: string[];\n    lastCheckpoint: number;\n    interventionCount: number;\n    refreshCount: number;\n  };\n  \n  // Historical data\n  metrics: CoherenceMetrics[];\n  interventions: {\n    timestamp: number;\n    type: 'checkpoint' | 'refresh' | 'restart' | 'guidance';\n    reason: string;\n    effectiveness: number; // 0-1\n  }[];\n}\n\n/**\n * Extended Coherence Manager\n * Orchestrates long-running agent sessions with coherence preservation\n */\nexport class ExtendedCoherenceManager {\n  private activeSessions: Map<string, CoherenceSession> = new Map();\n  private baseDir: string;\n  private monitoringInterval?: NodeJS.Timeout;\n  private performanceHistory: Map<string, number[]> = new Map();\n  \n  constructor(baseDir: string = './.coherence-sessions') {\n    this.baseDir = baseDir;\n  }\n\n  /**\n   * Initialize the coherence management system\n   */\n  async initialize(): Promise<void> {\n    await fs.mkdir(this.baseDir, { recursive: true });\n    \n    // Start monitoring loop\n    this.monitoringInterval = setInterval(\n      () => this.monitorActiveSessionsHealth(),\n      60000 // Check every minute\n    );\n    \n    logger.info('Extended Coherence Manager initialized', {\n      baseDir: this.baseDir,\n      monitoringEnabled: true,\n    });\n  }\n\n  /**\n   * Start an extended coherence work session\n   */\n  async startCoherenceSession(\n    agentConfig: { id: string; role: string; model: string },\n    taskConfig: {\n      description: string;\n      complexity: 'low' | 'medium' | 'high' | 'very_high';\n      estimatedDuration: number;\n      breakpoints?: string[];\n    },\n    sessionConfig?: Partial<CoherenceSession['config']>\n  ): Promise<string> {\n    const sessionId = uuidv4();\n    \n    // Configure session based on task complexity\n    const defaultConfig = this.generateConfigForComplexity(taskConfig.complexity);\n    const config = { ...defaultConfig, ...sessionConfig };\n    \n    const session: CoherenceSession = {\n      id: sessionId,\n      agent: agentConfig,\n      task: {\n        ...taskConfig,\n        breakpoints: taskConfig.breakpoints || this.generateBreakpoints(taskConfig),\n      },\n      config,\n      state: {\n        status: 'active',\n        currentPhase: 'initialization',\n        completedMilestones: [],\n        lastCheckpoint: Date.now(),\n        interventionCount: 0,\n        refreshCount: 0,\n      },\n      metrics: [],\n      interventions: [],\n    };\n\n    this.activeSessions.set(sessionId, session);\n    \n    // Initialize session workspace\n    await this.initializeSessionWorkspace(session);\n    \n    // Start the actual agent work session\n    await this.launchAgentSession(session);\n    \n    logger.info('Extended coherence session started', {\n      sessionId,\n      agent: agentConfig.role,\n      estimatedDuration: taskConfig.estimatedDuration,\n      maxDuration: config.maxDuration,\n    });\n\n    return sessionId;\n  }\n\n  /**\n   * Generate configuration optimized for task complexity\n   */\n  private generateConfigForComplexity(\n    complexity: 'low' | 'medium' | 'high' | 'very_high'\n  ): CoherenceSession['config'] {\n    const configs = {\n      low: {\n        maxDuration: 60, // 1 hour\n        coherenceThreshold: 0.7,\n        checkpointInterval: 15, // 15 minutes\n        refreshStrategy: 'checkpoint' as const,\n        enableMemoryPalace: false,\n        enableProgressTracking: true,\n        enableAutoRefresh: false,\n        enableHealthMonitoring: true,\n      },\n      medium: {\n        maxDuration: 180, // 3 hours\n        coherenceThreshold: 0.8,\n        checkpointInterval: 10, // 10 minutes\n        refreshStrategy: 'context_refresh' as const,\n        enableMemoryPalace: true,\n        enableProgressTracking: true,\n        enableAutoRefresh: true,\n        enableHealthMonitoring: true,\n      },\n      high: {\n        maxDuration: 360, // 6 hours\n        coherenceThreshold: 0.85,\n        checkpointInterval: 8, // 8 minutes\n        refreshStrategy: 'context_refresh' as const,\n        enableMemoryPalace: true,\n        enableProgressTracking: true,\n        enableAutoRefresh: true,\n        enableHealthMonitoring: true,\n      },\n      very_high: {\n        maxDuration: 720, // 12 hours\n        coherenceThreshold: 0.9,\n        checkpointInterval: 5, // 5 minutes\n        refreshStrategy: 'full_restart' as const,\n        enableMemoryPalace: true,\n        enableProgressTracking: true,\n        enableAutoRefresh: true,\n        enableHealthMonitoring: true,\n      },\n    };\n\n    return configs[complexity];\n  }\n\n  /**\n   * Monitor active sessions for coherence degradation\n   */\n  private async monitorActiveSessionsHealth(): Promise<void> {\n    for (const [sessionId, session] of this.activeSessions) {\n      if (session.state.status === 'active') {\n        await this.assessSessionCoherence(session);\n      }\n    }\n  }\n\n  /**\n   * Assess session coherence and intervene if necessary\n   */\n  private async assessSessionCoherence(session: CoherenceSession): Promise<void> {\n    const metrics = await this.calculateCoherenceMetrics(session);\n    session.metrics.push(metrics);\n    \n    // Keep only last 10 metrics for performance\n    if (session.metrics.length > 10) {\n      session.metrics.shift();\n    }\n\n    const overallCoherence = this.calculateOverallCoherence(metrics);\n    \n    logger.debug('Session coherence assessment', {\n      sessionId: session.id,\n      coherence: overallCoherence,\n      threshold: session.config.coherenceThreshold,\n      duration: metrics.duration,\n    });\n\n    // Intervene if coherence drops below threshold\n    if (overallCoherence < session.config.coherenceThreshold) {\n      await this.interventeInSession(session, 'coherence_degradation', overallCoherence);\n    }\n    \n    // Check if checkpoint is due\n    const timeSinceCheckpoint = Date.now() - session.state.lastCheckpoint;\n    const checkpointDue = timeSinceCheckpoint > (session.config.checkpointInterval * 60 * 1000);\n    \n    if (checkpointDue) {\n      await this.checkpointSession(session);\n    }\n  }\n\n  /**\n   * Calculate comprehensive coherence metrics\n   */\n  private async calculateCoherenceMetrics(session: CoherenceSession): Promise<CoherenceMetrics> {\n    const now = Date.now();\n    const duration = (now - session.metrics[0]?.startTime || now) / (1000 * 60); // minutes\n    \n    // Load recent agent outputs for analysis\n    const recentOutputs = await this.getRecentAgentOutputs(session);\n    \n    // Calculate various coherence indicators\n    const outputQuality = this.assessOutputQuality(recentOutputs);\n    const contextRetention = this.assessContextRetention(recentOutputs, session.task);\n    const taskRelevance = this.assessTaskRelevance(recentOutputs, session.task);\n    const repetitionRate = this.calculateRepetitionRate(recentOutputs);\n    const divergenceRate = this.calculateDivergenceRate(recentOutputs, session.task);\n    const errorRate = this.calculateErrorRate(recentOutputs);\n    const progressRate = this.calculateProgressRate(session);\n\n    return {\n      sessionId: session.id,\n      startTime: session.metrics[0]?.startTime || now,\n      currentTime: now,\n      duration,\n      outputQuality,\n      contextRetention,\n      taskRelevance,\n      progressRate,\n      repetitionRate,\n      divergenceRate,\n      errorRate,\n      memoryUsage: await this.getMemoryUsage(session),\n      contextWindowUsage: await this.getContextWindowUsage(session),\n      stateCheckpoints: session.interventions.filter(i => i.type === 'checkpoint').length,\n    };\n  }\n\n  /**\n   * Calculate overall coherence score\n   */\n  private calculateOverallCoherence(metrics: CoherenceMetrics): number {\n    // Weighted average of coherence indicators\n    const weights = {\n      outputQuality: 0.3,\n      contextRetention: 0.25,\n      taskRelevance: 0.25,\n      repetitionPenalty: 0.1, // penalty for repetition\n      divergencePenalty: 0.1, // penalty for divergence\n    };\n\n    const baseScore = \n      metrics.outputQuality * weights.outputQuality +\n      metrics.contextRetention * weights.contextRetention +\n      metrics.taskRelevance * weights.taskRelevance;\n    \n    const penalties = \n      metrics.repetitionRate * weights.repetitionPenalty +\n      metrics.divergenceRate * weights.divergencePenalty;\n\n    return Math.max(0, baseScore - penalties);\n  }\n\n  /**\n   * Intervene in a session to restore coherence\n   */\n  private async interventeInSession(\n    session: CoherenceSession,\n    reason: string,\n    currentCoherence: number\n  ): Promise<void> {\n    logger.warn('Intervening in session due to coherence degradation', {\n      sessionId: session.id,\n      reason,\n      currentCoherence,\n      interventionCount: session.state.interventionCount,\n    });\n\n    const intervention = {\n      timestamp: Date.now(),\n      type: session.config.refreshStrategy,\n      reason,\n      effectiveness: 0, // will be calculated later\n    };\n\n    switch (session.config.refreshStrategy) {\n      case 'checkpoint':\n        await this.checkpointSession(session);\n        break;\n        \n      case 'context_refresh':\n        await this.refreshSessionContext(session);\n        break;\n        \n      case 'full_restart':\n        await this.restartSession(session);\n        break;\n        \n      default:\n        await this.provideGuidance(session, reason);\n        intervention.type = 'guidance';\n    }\n\n    session.interventions.push(intervention);\n    session.state.interventionCount++;\n    \n    // Mark session as temporarily degraded\n    const previousStatus = session.state.status;\n    session.state.status = 'degraded';\n    \n    // Schedule restoration check\n    setTimeout(async () => {\n      const newMetrics = await this.calculateCoherenceMetrics(session);\n      const newCoherence = this.calculateOverallCoherence(newMetrics);\n      \n      // Calculate intervention effectiveness\n      intervention.effectiveness = Math.max(0, newCoherence - currentCoherence);\n      \n      if (newCoherence > session.config.coherenceThreshold) {\n        session.state.status = 'active';\n        logger.info('Session coherence restored', {\n          sessionId: session.id,\n          newCoherence,\n          effectiveness: intervention.effectiveness,\n        });\n      }\n    }, 120000); // Check after 2 minutes\n  }\n\n  /**\n   * Create a checkpoint of session state\n   */\n  private async checkpointSession(session: CoherenceSession): Promise<void> {\n    const checkpointPath = path.join(\n      this.baseDir,\n      session.id,\n      `checkpoint-${Date.now()}.json`\n    );\n    \n    const checkpointData = {\n      timestamp: Date.now(),\n      state: session.state,\n      recentMetrics: session.metrics.slice(-3),\n      currentPhase: session.state.currentPhase,\n      completedMilestones: session.state.completedMilestones,\n      // Include recent agent context\n      contextSummary: await this.generateContextSummary(session),\n    };\n\n    await fs.writeFile(checkpointPath, JSON.stringify(checkpointData, null, 2));\n    session.state.lastCheckpoint = Date.now();\n    \n    logger.info('Session checkpoint created', {\n      sessionId: session.id,\n      checkpointPath,\n    });\n  }\n\n  /**\n   * Refresh session context to restore coherence\n   */\n  private async refreshSessionContext(session: CoherenceSession): Promise<void> {\n    logger.info('Refreshing session context', { sessionId: session.id });\n    \n    // Generate context refresh prompt\n    const refreshPrompt = await this.generateContextRefreshPrompt(session);\n    \n    // Apply refresh to the running agent\n    await this.applyContextRefresh(session, refreshPrompt);\n    \n    session.state.refreshCount++;\n  }\n\n  /**\n   * Restart session from last good checkpoint\n   */\n  private async restartSession(session: CoherenceSession): Promise<void> {\n    logger.info('Restarting session from checkpoint', { sessionId: session.id });\n    \n    // Load last checkpoint\n    const checkpoint = await this.loadLatestCheckpoint(session);\n    \n    if (checkpoint) {\n      // Restore session state\n      session.state = { ...checkpoint.state };\n      \n      // Restart agent with checkpoint context\n      await this.restartAgentFromCheckpoint(session, checkpoint);\n    } else {\n      // No checkpoint available, restart from beginning\n      await this.restartAgentFromBeginning(session);\n    }\n  }\n\n  /**\n   * Initialize workspace for a coherence session\n   */\n  private async initializeSessionWorkspace(session: CoherenceSession): Promise<void> {\n    const sessionDir = path.join(this.baseDir, session.id);\n    await fs.mkdir(sessionDir, { recursive: true });\n    \n    // Create session manifest\n    const manifest = {\n      sessionId: session.id,\n      agent: session.agent,\n      task: session.task,\n      config: session.config,\n      createdAt: Date.now(),\n    };\n    \n    await fs.writeFile(\n      path.join(sessionDir, 'manifest.json'),\n      JSON.stringify(manifest, null, 2)\n    );\n  }\n\n  /**\n   * Launch the actual agent work session\n   */\n  private async launchAgentSession(session: CoherenceSession): Promise<void> {\n    const sessionDir = path.join(this.baseDir, session.id);\n    \n    // Create enhanced Ralph bridge for extended sessions\n    const ralph = new RalphStackMemoryBridge({\n      baseDir: sessionDir,\n      maxIterations: Math.ceil(session.config.maxDuration / 5), // ~5 min per iteration\n      useStackMemory: true,\n    });\n\n    // Configure for extended coherence\n    await ralph.initialize({\n      task: this.buildExtendedCoherencePrompt(session),\n      criteria: session.task.breakpoints.join('\\n'),\n    });\n\n    // Start the session (non-blocking)\n    ralph.run().catch(error => {\n      logger.error('Extended coherence session failed', {\n        sessionId: session.id,\n        error: error.message,\n      });\n      session.state.status = 'failed';\n    });\n  }\n\n  /**\n   * Build prompt optimized for extended coherence\n   */\n  private buildExtendedCoherencePrompt(session: CoherenceSession): string {\n    return `\n# EXTENDED COHERENCE WORK SESSION\n\n## Your Mission\n${session.task.description}\n\n## Session Parameters\n- Estimated Duration: ${session.task.estimatedDuration} minutes\n- Maximum Duration: ${session.config.maxDuration} minutes  \n- Coherence Threshold: ${session.config.coherenceThreshold * 100}%\n\n## Coherence Guidelines\n1. **Maintain Focus**: Stay on task throughout the entire session\n2. **Track Progress**: Document incremental progress at each step\n3. **Context Awareness**: Reference previous work and maintain consistency\n4. **Quality Control**: Regularly assess your output quality\n5. **Milestone Reporting**: Report when you reach natural breakpoints\n\n## Breakpoints & Milestones\n${session.task.breakpoints.map((bp, i) => `${i + 1}. ${bp}`).join('\\n')}\n\n## Extended Session Strategy\n- Take regular checkpoint breaks (every ${session.config.checkpointInterval} minutes)\n- Summarize your progress regularly\n- Ask for context refresh if you feel you're losing focus\n- Maintain awareness of the overall project goal\n- Break complex tasks into smaller, manageable chunks\n\n## Memory Palace (if enabled)\n${session.config.enableMemoryPalace ? `\nUse structured memory organization:\n- **Project Context**: Overall goals and requirements\n- **Current Status**: What's been completed and what's next\n- **Working Memory**: Current task details and immediate context\n- **Reference Memory**: Important patterns, decisions, and learnings\n` : ''}\n\n## Success Criteria\n- Complete the task within the allocated time\n- Maintain high output quality throughout\n- Document progress and decisions clearly\n- Stay coherent and focused for the entire session\n\nBegin your extended coherence work session now.\n    `;\n  }\n\n  // Placeholder implementations for helper methods\n  private async getRecentAgentOutputs(session: CoherenceSession): Promise<any[]> {\n    // Implementation to retrieve recent agent outputs\n    return [];\n  }\n\n  private assessOutputQuality(outputs: any[]): number {\n    // Analyze output quality metrics\n    return 0.8; // placeholder\n  }\n\n  private assessContextRetention(outputs: any[], task: any): number {\n    // Measure how well agent retains context\n    return 0.7; // placeholder  \n  }\n\n  private assessTaskRelevance(outputs: any[], task: any): number {\n    // Measure relevance to original task\n    return 0.9; // placeholder\n  }\n\n  private calculateRepetitionRate(outputs: any[]): number {\n    // Calculate how often agent repeats itself\n    return 0.1; // placeholder\n  }\n\n  private calculateDivergenceRate(outputs: any[], task: any): number {\n    // Calculate how often agent goes off-topic\n    return 0.05; // placeholder\n  }\n\n  private calculateErrorRate(outputs: any[]): number {\n    // Calculate errors per iteration\n    return 0.02; // placeholder\n  }\n\n  private calculateProgressRate(session: CoherenceSession): number {\n    // Calculate tasks completed per hour\n    return 2.5; // placeholder\n  }\n\n  private async getMemoryUsage(session: CoherenceSession): Promise<number> {\n    // Get current memory usage\n    return 150; // MB placeholder\n  }\n\n  private async getContextWindowUsage(session: CoherenceSession): Promise<number> {\n    // Get context window usage percentage\n    return 65; // placeholder\n  }\n\n  private generateBreakpoints(taskConfig: any): string[] {\n    // Generate natural stopping points based on task\n    return [\n      'Initial analysis complete',\n      'Core implementation finished',\n      'Testing phase complete',\n      'Final review and cleanup done',\n    ];\n  }\n\n  private async generateContextSummary(session: CoherenceSession): Promise<string> {\n    return `Session ${session.id} context summary`;\n  }\n\n  private async generateContextRefreshPrompt(session: CoherenceSession): Promise<string> {\n    return 'Context refresh prompt';\n  }\n\n  private async applyContextRefresh(session: CoherenceSession, prompt: string): Promise<void> {\n    // Apply context refresh to running agent\n  }\n\n  private async loadLatestCheckpoint(session: CoherenceSession): Promise<any> {\n    // Load most recent checkpoint\n    return null;\n  }\n\n  private async restartAgentFromCheckpoint(session: CoherenceSession, checkpoint: any): Promise<void> {\n    // Restart agent with checkpoint state\n  }\n\n  private async restartAgentFromBeginning(session: CoherenceSession): Promise<void> {\n    // Restart agent from the beginning\n  }\n\n  private async provideGuidance(session: CoherenceSession, reason: string): Promise<void> {\n    // Provide guidance to help agent refocus\n  }\n\n  /**\n   * Get extended coherence capabilities\n   */\n  getCoherenceCapabilities(): {\n    maxSessionDuration: number;\n    activeSessionCount: number;\n    averageCoherence: number;\n    totalInterventions: number;\n  } {\n    const activeSessions = Array.from(this.activeSessions.values());\n    \n    return {\n      maxSessionDuration: Math.max(...activeSessions.map(s => s.config.maxDuration)),\n      activeSessionCount: activeSessions.filter(s => s.state.status === 'active').length,\n      averageCoherence: activeSessions.reduce((sum, s) => {\n        const recent = s.metrics.slice(-1)[0];\n        return sum + (recent ? this.calculateOverallCoherence(recent) : 0);\n      }, 0) / activeSessions.length,\n      totalInterventions: activeSessions.reduce((sum, s) => sum + s.interventions.length, 0),\n    };\n  }\n}\n\nexport default ExtendedCoherenceManager;"],
+  "mappings": "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",
+  "names": []
+}