/**
 * ChainHandoffService — Lifecycle Module
 *
 * Knowledge stack, supervisor engine, cycle management, and auto-escalation.
 * ADR-101 Stages 2 & 3.
 */

import { dbRun, isPostgres } from '../../database/connection.js';
import { apiLogger } from '../../utils/logger.js';
import { generateBaseId } from '../../utils/baseId.js';
import {
  STATE,
  AGENT_USERS,
  TICKETS_TABLE_ID,
  SUPERVISOR_CONFIG,
  generateChainId,
} from './constants.js';
import { getAgentName } from './routing.js';

// T6 fix: In-memory mutex to prevent concurrent supervisor triggers for the same chain
const _supervisorLocks = new Set();

// ----- ADR-101 STAGE 2: KNOWLEDGE STACK -----

/**
 * Build a structured knowledge summary from chain tasks.
 * Parses task `why` fields to extract decisions, resolved/unresolved issues,
 * and artifacts (files, test results).
 *
 * ADR-101 Stage 2: Data collection only — no cycle restart.
 *
 * @param {Array} chainTasks - Array of tasks from getChainTasks()
 * @returns {Object} Structured knowledge summary
 */
function buildKnowledgeSummary(chainTasks) {
  if (!chainTasks || chainTasks.length === 0) {
    return {
      summary: 'No tasks in chain.',
      tasks: [],
      decisions: [],
      resolved: [],
      unresolved: [],
      artifacts: { files_created: [], files_modified: [], tests_passed: 0, tests_failed: 0 },
    };
  }

  const decisions = new Set();
  const resolved = new Set();
  const unresolved = new Set();
  const filesCreated = new Set();
  const filesModified = new Set();
  let testsPassed = 0;
  let testsFailed = 0;

  const taskSummaries = [];

  for (const task of chainTasks) {
    const why = task.why || '';

    // Extract structured markers from why field
    const decisionMatches = why.match(/DECISION:\s*([^\n]+)/gi) || [];
    for (const m of decisionMatches) {
      decisions.add(m.replace(/^DECISION:\s*/i, '').trim());
    }

    const resolvedMatches = why.match(/(?:RESOLVED|FIXED):\s*([^\n]+)/gi) || [];
    for (const m of resolvedMatches) {
      resolved.add(m.replace(/^(?:RESOLVED|FIXED):\s*/i, '').trim());
    }

    const unresolvedMatches = why.match(/(?:BLOCKER|UNRESOLVED|FAILED):\s*([^\n]+)/gi) || [];
    for (const m of unresolvedMatches) {
      unresolved.add(m.replace(/^(?:BLOCKER|UNRESOLVED|FAILED):\s*/i, '').trim());
    }

    // Extract file paths
    const createdFiles = why.match(/(?:created|wrote|generated):\s*([^\n]+)/gi) || [];
    for (const m of createdFiles) {
      const path = m.replace(/^(?:created|wrote|generated):\s*/i, '').trim();
      if (path && path.length < 200) filesCreated.add(path);
    }

    const modifiedFiles = why.match(/(?:modified|updated|changed):\s*([^\n]+)/gi) || [];
    for (const m of modifiedFiles) {
      const path = m.replace(/^(?:modified|updated|changed):\s*/i, '').trim();
      if (path && path.length < 200) filesModified.add(path);
    }

    // Extract test counts
    const passMatch = why.match(/(\d+)\s*(?:tests?\s*)?pass(?:ed|ing)?/i);
    if (passMatch) testsPassed += parseInt(passMatch[1], 10);

    const failMatch = why.match(/(\d+)\s*(?:tests?\s*)?fail(?:ed|ing)?/i);
    if (failMatch) testsFailed += parseInt(failMatch[1], 10);

    // Task summary
    taskSummaries.push({
      step: task.step,
      what: task.what,
      state: task.chain_status || 'unknown',
      assigned_to: getAgentName(task.assigned_to),
    });
  }

  // Build condensed summary text
  const completedCount = chainTasks.filter(
    t => t.state === STATE.DONE || t.chain_status === 'completed'
  ).length;

  const summaryParts = [
    `${completedCount}/${chainTasks.length} tasks completed.`,
  ];
  if (decisions.size > 0) summaryParts.push(`Decisions: ${[...decisions].join('; ')}.`);
  if (resolved.size > 0) summaryParts.push(`Resolved: ${[...resolved].join('; ')}.`);
  if (unresolved.size > 0) summaryParts.push(`Unresolved: ${[...unresolved].join('; ')}.`);
  if (testsPassed > 0 || testsFailed > 0) {
    summaryParts.push(`Tests: ${testsPassed} passed, ${testsFailed} failed.`);
  }

  return {
    summary: summaryParts.join(' '),
    tasks: taskSummaries,
    decisions: [...decisions],
    resolved: [...resolved],
    unresolved: [...unresolved],
    artifacts: {
      files_created: [...filesCreated],
      files_modified: [...filesModified],
      tests_passed: testsPassed,
      tests_failed: testsFailed,
    },
  };
}

/**
 * Build a knowledge stack entry for a completed cycle.
 * Standardized format stored in knowledge_stack[] across cycles.
 *
 * ADR-101 Stage 2: Builder ready, used by triggerSupervisor() in Stage 3.
 *
 * @param {Object} params
 * @param {number} params.cycle - Cycle number (1-based)
 * @param {string} params.chainId - Chain ID for this cycle
 * @param {string} params.startedAt - ISO timestamp when cycle started
 * @param {Object} params.knowledgeSummary - Result from buildKnowledgeSummary()
 * @returns {Object} Knowledge stack entry
 */
function buildCycleKnowledgeEntry(params) {
  const { cycle, chainId, startedAt, knowledgeSummary } = params;

  return {
    cycle,
    chain_id: chainId,
    started_at: startedAt,
    completed_at: new Date().toISOString(),
    tasks_completed: knowledgeSummary.tasks.filter(t => t.state === 'completed').length,
    tasks_total: knowledgeSummary.tasks.length,
    summary: knowledgeSummary.summary,
    key_decisions: knowledgeSummary.decisions,
    blockers_resolved: knowledgeSummary.resolved,
    unresolved_issues: knowledgeSummary.unresolved,
    artifacts: knowledgeSummary.artifacts,
  };
}

/**
 * Format accumulated knowledge stack into a readable supervisor context string.
 * Used by triggerSupervisor() (Stage 3) to build the prompt for Nikich.
 *
 * ADR-101 Stage 2: Method ready, not yet called in production.
 *
 * @param {Object} params
 * @param {Array} params.knowledgeStack - Previous cycle knowledge entries
 * @param {Object} params.currentCycleKnowledge - Current cycle's buildKnowledgeSummary result
 * @param {string} params.originalGoal - Original task goal (never changes across cycles)
 * @param {number} params.cycleNumber - Current cycle number (1-based)
 * @param {string} params.chainId - Current chain ID
 * @returns {string} Formatted supervisor context
 */
function formatSupervisorContext(params) {
  const {
    knowledgeStack = [],
    currentCycleKnowledge = {},
    originalGoal = 'Unknown goal',
    cycleNumber = 1,
    chainId = '',
  } = params;

  const lines = [];
  const maxCycles = SUPERVISOR_CONFIG.max_cycles;

  lines.push(`[SUPERVISOR MODE — Cycle ${cycleNumber}/${maxCycles}]`);
  lines.push(`Goal: ${originalGoal}`);
  lines.push(`Current chain: ${chainId}`);
  lines.push('');

  // Previous cycles
  if (knowledgeStack.length > 0) {
    lines.push('=== PREVIOUS CYCLES ===');
    for (const entry of knowledgeStack) {
      lines.push(`--- Cycle ${entry.cycle} (${entry.chain_id}) ---`);
      lines.push(`Tasks: ${entry.tasks_completed}/${entry.tasks_total} completed`);
      if (entry.started_at && entry.completed_at) {
        lines.push(`Time: ${entry.started_at} → ${entry.completed_at}`);
      }
      lines.push(`Summary: ${entry.summary}`);
      if (entry.key_decisions?.length > 0) {
        lines.push(`Decisions: ${entry.key_decisions.join('; ')}`);
      }
      if (entry.blockers_resolved?.length > 0) {
        lines.push(`Resolved: ${entry.blockers_resolved.join('; ')}`);
      }
      if (entry.unresolved_issues?.length > 0) {
        lines.push(`⚠ Unresolved: ${entry.unresolved_issues.join('; ')}`);
      }
      if (entry.artifacts) {
        if (entry.artifacts.files_created?.length > 0) {
          lines.push(`Files created: ${entry.artifacts.files_created.join(', ')}`);
        }
        if (entry.artifacts.files_modified?.length > 0) {
          lines.push(`Files modified: ${entry.artifacts.files_modified.join(', ')}`);
        }
        lines.push(`Tests: ${entry.artifacts.tests_passed || 0} passed, ${entry.artifacts.tests_failed || 0} failed`);
      }
      lines.push('');
    }
  }

  // Current cycle
  lines.push('=== CURRENT CYCLE ===');
  lines.push(`Summary: ${currentCycleKnowledge.summary || 'No data'}`);
  if (currentCycleKnowledge.decisions?.length > 0) {
    lines.push(`Decisions: ${currentCycleKnowledge.decisions.join('; ')}`);
  }
  if (currentCycleKnowledge.resolved?.length > 0) {
    lines.push(`Resolved: ${currentCycleKnowledge.resolved.join('; ')}`);
  }
  if (currentCycleKnowledge.unresolved?.length > 0) {
    lines.push(`⚠ Unresolved: ${currentCycleKnowledge.unresolved.join('; ')}`);
  }
  if (currentCycleKnowledge.artifacts) {
    const a = currentCycleKnowledge.artifacts;
    if (a.files_created?.length > 0) lines.push(`Files created: ${a.files_created.join(', ')}`);
    if (a.files_modified?.length > 0) lines.push(`Files modified: ${a.files_modified.join(', ')}`);
    lines.push(`Tests: ${a.tests_passed || 0} passed, ${a.tests_failed || 0} failed`);
  }
  lines.push('');

  // Task details
  if (currentCycleKnowledge.tasks?.length > 0) {
    lines.push('Tasks in this cycle:');
    for (const t of currentCycleKnowledge.tasks) {
      lines.push(`  Step ${t.step}: [${t.state}] ${t.what} → ${t.assigned_to}`);
    }
    lines.push('');
  }

  // Decision instructions
  lines.push('=== YOUR DECISION ===');
  lines.push('Use the supervisor_decide tool with ONE of:');
  lines.push('  CONTINUE — unresolved tasks or failing tests. Provide next_cycle_plan.');
  lines.push('  COMPLETE — all acceptance criteria met. Provide final summary.');
  lines.push('  ESCALATE — blocker that agents cannot resolve. Provide blocker description.');

  return lines.join('\n');
}

// ----- ADR-101 STAGE 3: SUPERVISOR ENGINE -----

/**
 * T7 fix: Ensure the why field contains knowledge-parseable markers.
 * If no markers are present, appends a reminder template so agents
 * produce structured output that buildKnowledgeSummary() can parse.
 */
function _enforceKnowledgeMarkers(why) {
  if (!why || typeof why !== 'string') return why || '';
  const hasMarkers = /(?:DECISION|RESOLVED|FIXED|BLOCKER|UNRESOLVED|FAILED):/i.test(why);
  if (hasMarkers) return why;
  return why + '\n\n[When completing this task, include structured markers in your response: DECISION: <what you decided>, RESOLVED: <what you fixed>, BLOCKER: <unresolved issues>]';
}

/**
 * Trigger the Chain Supervisor (Nikich) at the configured step.
 * Collects all chain data, builds knowledge summary, and dispatches
 * a supervisor task with full memory.
 *
 * ADR-101 Stage 3: Core supervisor trigger.
 *
 * @param {Object} params
 * @param {string} params.chain_id - Current chain ID
 * @param {number} params.cycle_number - Current cycle number (1-based)
 * @param {string} params.cycle_group_id - Group ID shared across all cycles
 * @param {string} params.original_goal - Original task goal (never changes)
 * @param {Array} params.knowledge_stack - Previous cycle summaries
 * @returns {Promise<Object>} Supervisor ticket
 */
async function triggerSupervisor({ chain_id, cycle_number, cycle_group_id, original_goal, knowledge_stack, space_id }) {
  // T6 fix: Prevent concurrent supervisor triggers for the same chain
  if (_supervisorLocks.has(chain_id)) {
    apiLogger.warn({ chain_id, cycle_number }, 'ChainHandoff: Supervisor trigger already in progress for this chain — skipping duplicate');
    return { _supervisor: true, _duplicate: true, chain_id, cycle_number };
  }
  _supervisorLocks.add(chain_id);

  try {
  // 1. Gather all tasks in this chain
  const chainTasks = await this.getChainTasks(chain_id);
  const chainStatus = await this.getChainStatus(chain_id);

  // 2. Build knowledge summary for current cycle
  const currentSummary = buildKnowledgeSummary(chainTasks);

  // 3. Build cycle knowledge entry and append to stack
  const cycleEntry = buildCycleKnowledgeEntry({
    cycle: cycle_number,
    chainId: chain_id,
    startedAt: chainTasks[0]?.dispatched_at || new Date().toISOString(),
    knowledgeSummary: currentSummary,
  });

  const updatedStack = [...knowledge_stack, cycleEntry];

  // 4. Format context for supervisor prompt
  const supervisorContext = formatSupervisorContext({
    knowledgeStack: knowledge_stack,
    currentCycleKnowledge: currentSummary,
    originalGoal: original_goal,
    cycleNumber: cycle_number,
    chainId: chain_id,
  });

  // 5. Log cycle transition
  await this.logActivity({
    action: 'supervisor_triggered',
    agent_id: SUPERVISOR_CONFIG.supervisor_agent_id,
    chain_id,
    details: {
      cycle_number,
      cycle_group_id,
      tasks_in_cycle: chainTasks.length,
      completed: chainStatus.progress?.completed || 0,
      summary: currentSummary.summary.substring(0, 500),
    },
  });

  // 6. Dispatch supervisor task to Nikich (bypass normal dispatch to avoid re-trigger)
  const baseId = generateBaseId('ticket');
  const ticketData = {
    what: `[SUPERVISOR] Cycle ${cycle_number} analysis: ${original_goal.substring(0, 100)}`,
    why: supervisorContext,
    assigned_to: SUPERVISOR_CONFIG.supervisor_agent_id,
    priority: 24274, // high
    type: 24269,     // task
    state: STATE.BACKLOG,
    acceptance_criteria: 'Analyze cycle results and decide: CONTINUE / COMPLETE / ESCALATE',
    _chain: {
      chain_id,
      step: SUPERVISOR_CONFIG.trigger_at_step,
      dispatched_by: AGENT_USERS.ORCHESTRATOR,
      dispatched_at: new Date().toISOString(),
      status: 'dispatched',
    },
    _chain_memory: {
      cycle_number,
      cycle_group_id,
      parent_chain_id: chain_id,
      knowledge_stack: updatedStack,
      original_goal,
    },
  };

  const dataJson = JSON.stringify(ticketData);
  let result;
  if (isPostgres()) {
    result = await dbRun(
      `INSERT INTO table_rows (table_id, base_id, data, created_at, updated_at)
       VALUES ($1, $2, $3::jsonb, NOW(), NOW()) RETURNING id`,
      [TICKETS_TABLE_ID, baseId, dataJson]
    );
  } else {
    result = await dbRun(
      `INSERT INTO table_rows (table_id, base_id, data, created_at, updated_at)
       VALUES (?, ?, ?, datetime('now'), datetime('now'))`,
      [TICKETS_TABLE_ID, baseId, dataJson]
    );
  }

  const ticketId = result?.lastInsertRowid || result?.rows?.[0]?.id;

  apiLogger.info({
    ticketId,
    chain_id,
    cycle_number,
    cycle_group_id,
  }, 'ChainHandoff: Supervisor triggered (ADR-101)');

  // === T4 fix: Schedule timeout fallback if Nikich doesn't pick up ===
  const supervisorTimeoutMs = SUPERVISOR_CONFIG.supervisor_timeout_ms || 10 * 60 * 1000; // 10 min default
  setTimeout(async () => {
    try {
      // Check if supervisor ticket is still in BACKLOG (not picked up)
      const ticket = await this.getTicket(ticketId);
      const tData = typeof ticket?.data === 'string' ? JSON.parse(ticket.data) : (ticket?.data || {});
      if (tData.state === STATE.BACKLOG) {
        apiLogger.warn({ ticketId, chain_id, cycle_number },
          'ChainHandoff: Supervisor timeout — Nikich offline, auto-escalating');
        await this.autoEscalate(chain_id, ticketData._chain_memory, 'SUPERVISOR_TIMEOUT', space_id);
      }
    } catch (timeoutErr) {
      apiLogger.error({ err: timeoutErr, ticketId },
        'ChainHandoff: Supervisor timeout check failed');
    }
  }, supervisorTimeoutMs);

  return {
    ticket_id: ticketId,
    chain_id,
    step: SUPERVISOR_CONFIG.trigger_at_step,
    cycle_number,
    cycle_group_id,
    state: STATE.BACKLOG,
    assigned_to: SUPERVISOR_CONFIG.supervisor_agent_id,
    what: ticketData.what,
    data: ticketData,
    _supervisor: true, // flag for callers to know this is a supervisor ticket
  };

  } finally {
    // T6 fix: Release lock after supervisor trigger completes (or fails)
    _supervisorLocks.delete(chain_id);
  }
}

/**
 * Start a new chain cycle with accumulated knowledge.
 * Creates a new chain_id, resets step to 1, carries forward full memory.
 *
 * ADR-101 Stage 3: Cycle restart with memory propagation.
 *
 * @param {Object} params
 * @param {string} params.cycle_group_id - Shared group ID across all cycles
 * @param {number} params.cycle_number - New cycle number (1-based)
 * @param {Array} params.knowledge_stack - All previous cycle summaries
 * @param {string} params.original_goal - Original task goal (constant)
 * @param {string} params.next_cycle_plan - Plan text from supervisor's decision
 * @param {Array<Object>} params.tasks - Task list [{what, assigned_to, why?, priority?}]
 * @returns {Promise<Object>} New chain with all dispatched tasks
 */
async function startNewCycle({ cycle_group_id, cycle_number, knowledge_stack, original_goal, next_cycle_plan, tasks }) {
  const newChainId = generateChainId();

  // Log new cycle start
  await this.logActivity({
    action: 'cycle_started',
    agent_id: SUPERVISOR_CONFIG.supervisor_agent_id,
    chain_id: newChainId,
    details: {
      cycle_number,
      cycle_group_id,
      parent_chain_id: knowledge_stack[knowledge_stack.length - 1]?.chain_id,
      plan: next_cycle_plan?.substring(0, 500),
      tasks_count: tasks.length,
    },
  });

  // ADR-109 Part D: FYI notification at cycle 3+ (non-blocking audit trail)
  if (cycle_number >= 3) {
    try {
      await this.logActivity({
        action: 'cycle_fyi_notification',
        agent_id: SUPERVISOR_CONFIG.supervisor_agent_id,
        chain_id: newChainId,
        details: {
          cycle: cycle_number,
          cycle_group_id,
          original_goal: original_goal?.substring(0, 200),
          message: `Cycle ${cycle_number} started, human may want to review`,
        },
      });
      apiLogger.info({ cycle_number, cycle_group_id, newChainId },
        'ChainHandoff: Cycle 3+ FYI notification logged (ADR-109)');
    } catch (err) {
      // Non-blocking — FYI logging should never break the cycle
      apiLogger.warn({ err, cycle_number }, 'ChainHandoff: Failed to log cycle FYI notification');
    }
  }

  // Dispatch tasks with memory propagation (max trigger_at_step - 1 tasks)
  const maxTasks = SUPERVISOR_CONFIG.trigger_at_step - 1; // 8 tasks max
  const results = [];
  for (let i = 0; i < tasks.length && i < maxTasks; i++) {
    const task = tasks[i];
    const result = await this.dispatchSubtask({
      what: task.what,
      why: _enforceKnowledgeMarkers(task.why || `[Cycle ${cycle_number}] ${next_cycle_plan || ''}`.substring(0, 500)),
      assigned_to: task.assigned_to,
      priority: task.priority || 24274,
      chain_id: newChainId,
      step: i + 1,
      dispatched_by: SUPERVISOR_CONFIG.supervisor_agent_id,
      _chain_memory: {
        cycle_number,
        cycle_group_id,
        parent_chain_id: knowledge_stack[knowledge_stack.length - 1]?.chain_id,
        knowledge_stack,
        original_goal,
      },
    });
    results.push(result);
  }

  apiLogger.info({
    newChainId,
    cycle_number,
    cycle_group_id,
    tasksDispatched: results.length,
  }, 'ChainHandoff: New cycle started (ADR-101)');

  return {
    chain_id: newChainId,
    cycle_number,
    cycle_group_id,
    original_goal,
    tasks: results,
  };
}

/**
 * Auto-escalate when safety limits are breached.
 * Creates an escalation ticket with full cycle history.
 *
 * ADR-101 Stage 3: Safety guard escalation.
 *
 * @param {string} chain_id - Current chain ID
 * @param {Object} memory - Chain memory object (_chain_memory)
 * @param {string} reason - Escalation reason code
 * @returns {Promise<Object>} Escalation ticket
 */
async function autoEscalate(chain_id, memory, reason) {
  const reasonMessages = {
    MAX_CYCLES_REACHED: `Maximum cycles reached (${SUPERVISOR_CONFIG.max_cycles})`,
    MAX_DURATION_REACHED: `Maximum duration reached (${SUPERVISOR_CONFIG.max_duration_ms / 3600000}h)`,
    MAX_TASKS_REACHED: `Maximum total tasks reached (${SUPERVISOR_CONFIG.max_total_tasks})`,
    SUPERVISOR_TIMEOUT: `Supervisor (Nikich) did not pick up within timeout (${(SUPERVISOR_CONFIG.supervisor_timeout_ms || 600000) / 60000} min)`,
  };

  const report = [
    `AUTO-ESCALATION: ${reasonMessages[reason] || reason}`,
    '',
    `Goal: ${memory.original_goal || 'unknown'}`,
    `Cycles completed: ${memory.cycle_number || 0}`,
    `Cycle group: ${memory.cycle_group_id || 'unknown'}`,
    '',
    '--- Knowledge from all cycles ---',
    ...(memory.knowledge_stack || []).map(k =>
      `Cycle ${k.cycle}: ${k.summary || 'no summary'}`
    ),
  ].join('\n');

  await this.logActivity({
    action: 'supervisor_auto_escalate',
    agent_id: SUPERVISOR_CONFIG.supervisor_agent_id,
    chain_id,
    details: {
      reason,
      cycle_number: memory.cycle_number,
      cycle_group_id: memory.cycle_group_id,
      original_goal: memory.original_goal,
    },
  });

  apiLogger.warn({
    chain_id,
    reason,
    cycle_number: memory.cycle_number,
  }, 'ChainHandoff: Auto-escalation triggered (ADR-101)');

  // Create escalation ticket assigned to orchestrator for human review
  const baseId = generateBaseId('ticket');
  const ticketData = {
    what: `[ESCALATION] ${reasonMessages[reason] || reason}: ${(memory.original_goal || '').substring(0, 80)}`,
    why: report,
    assigned_to: AGENT_USERS.ORCHESTRATOR,
    priority: 24274,
    type: 24269,
    state: STATE.BACKLOG,
    _chain: {
      chain_id,
      step: SUPERVISOR_CONFIG.trigger_at_step,
      dispatched_by: SUPERVISOR_CONFIG.supervisor_agent_id,
      dispatched_at: new Date().toISOString(),
      status: 'escalated',
    },
    _chain_memory: memory,
    _escalation: {
      reason,
      escalated_at: new Date().toISOString(),
      auto: true,
    },
  };

  const dataJson = JSON.stringify(ticketData);
  let result;
  if (isPostgres()) {
    result = await dbRun(
      `INSERT INTO table_rows (table_id, base_id, data, created_at, updated_at)
       VALUES ($1, $2, $3::jsonb, NOW(), NOW()) RETURNING id`,
      [TICKETS_TABLE_ID, baseId, dataJson]
    );
  } else {
    result = await dbRun(
      `INSERT INTO table_rows (table_id, base_id, data, created_at, updated_at)
       VALUES (?, ?, ?, datetime('now'), datetime('now'))`,
      [TICKETS_TABLE_ID, baseId, dataJson]
    );
  }

  const ticketId = result?.lastInsertRowid || result?.rows?.[0]?.id;

  return {
    ticket_id: ticketId,
    chain_id,
    step: SUPERVISOR_CONFIG.trigger_at_step,
    state: STATE.BACKLOG,
    assigned_to: AGENT_USERS.ORCHESTRATOR,
    what: ticketData.what,
    data: ticketData,
    _escalation: true,
  };
}

export {
  buildKnowledgeSummary,
  buildCycleKnowledgeEntry,
  formatSupervisorContext,
  triggerSupervisor,
  startNewCycle,
  autoEscalate,
};