Workflow de Missão de Resgate

// scripts/rescue-tracker.ts
interface RescueMission {
  id: string;
  taskId: string;
  detectedAt: Date;
  resolvedAt: Date | null;
  diagnosis: {
    category: string;
    evidence: string[];
    rootCause: string;
  };
  injection: {
    description: string;
    filesAdded: string[];
    specChanges: string[];
  };
  outcome: "resolved" | "re-escalated" | "abandoned";
  contextUpdates: string[];
  mttu: number | null; // minutes from detection to resolution
}

function calculateMTTU(missions: RescueMission[]): number {
  const resolved = missions.filter(
    (m) => m.outcome === "resolved" && m.mttu !== null
  );
  if (resolved.length === 0) return 0;
  return resolved.reduce((sum, m) => sum + (m.mttu ?? 0), 0) / resolved.length;
}

function categoryBreakdown(
  missions: RescueMission[]
): Record<string, number> {
  return missions.reduce(
    (acc, m) => {
      const cat = m.diagnosis.category;
      acc[cat] = (acc[cat] || 0) + 1;
      return acc;
    },
    {} as Record<string, number>
  );
}

function generateRescueReport(missions: RescueMission[]): string {
  const mttu = calculateMTTU(missions);
  const breakdown = categoryBreakdown(missions);
  const totalContextUpdates = missions.reduce(
    (sum, m) => sum + m.contextUpdates.length,
    0
  );

  return [
    `## Rescue Mission Report`,
    ``,
    `**Period:** Last 30 days`,
    `**Total Rescues:** ${missions.length}`,
    `**Average MTTU:** ${mttu.toFixed(0)} minutes`,
    `**Context Updates Generated:** ${totalContextUpdates}`,
    ``,
    `### Root Cause Breakdown`,
    ...Object.entries(breakdown)
      .sort(([, a], [, b]) => b - a)
      .map(
        ([cat, count]) =>
          `- ${cat}: ${count} (${((count / missions.length) * 100).toFixed(0)}%)`
      ),
  ].join("\n");
}

// scripts/detect-blockers.ts
interface AgentSession {
  id: string;
  taskId: string;
  startedAt: Date;
  tokenBudget: number;
  tokensUsed: number;
  retryCount: number;
  lastGateResult: "pass" | "fail";
  lastError: string | null;
  expectedDurationMinutes: number;
}

interface BlockerAlert {
  sessionId: string;
  taskId: string;
  reason: string;
  severity: "warning" | "critical";
  suggestedAction: string;
}

function detectBlockers(sessions: AgentSession[]): BlockerAlert[] {
  const alerts: BlockerAlert[] = [];
  const now = new Date();

  for (const session of sessions) {
    const elapsedMinutes =
      (now.getTime() - session.startedAt.getTime()) / 60000;
    const budgetPercent = (session.tokensUsed / session.tokenBudget) * 100;

    // Check: token budget approaching limit
    if (budgetPercent > 80 && session.lastGateResult === "fail") {
      alerts.push({
        sessionId: session.id,
        taskId: session.taskId,
        reason: `Token budget at ${budgetPercent.toFixed(0)}% with failing gates`,
        severity: "critical",
        suggestedAction: "Initiate rescue mission — budget exhaustion likely",
      });
    }

    // Check: excessive retries
    if (session.retryCount >= 3) {
      alerts.push({
        sessionId: session.id,
        taskId: session.taskId,
        reason: `${session.retryCount} retries with no improvement`,
        severity: "critical",
        suggestedAction:
          "Raise blocker flag — automated retries are not resolving the issue",
      });
    }

    // Check: running longer than expected
    if (elapsedMinutes > session.expectedDurationMinutes * 2) {
      alerts.push({
        sessionId: session.id,
        taskId: session.taskId,
        reason: `Running ${elapsedMinutes.toFixed(0)}min (expected ${session.expectedDurationMinutes}min)`,
        severity: "warning",
        suggestedAction:
          "Check agent progress — may be stuck or working on out-of-scope items",
      });
    }
  }

  return alerts;
}