@rallycry/conveyor-agent 7.2.5 → 7.2.6

package/dist/task-audit-handler-6TZRN3YB.js

@@ -0,0 +1,885 @@
+import {
+  textResult
+} from "./chunk-C5YAMQJ2.js";
+import {
+  createHarness,
+  createServiceLogger,
+  defineTool
+} from "./chunk-RRXX6DTB.js";
+
+// src/runner/task-audit-handler.ts
+import { z } from "zod";
+
+// src/runner/task-audit-parsing.ts
+function formatMacroEvaluation(macro) {
+  if (!macro) return null;
+  const lines = [];
+  if (macro.instructionsQuality) lines.push(`- Instructions Quality: ${macro.instructionsQuality}`);
+  if (macro.modelSuitability) lines.push(`- Model Suitability: ${macro.modelSuitability}`);
+  if (macro.contextAndPlanning) lines.push(`- Context & Planning: ${macro.contextAndPlanning}`);
+  if (macro.overallResult) lines.push(`- Overall Result: ${macro.overallResult}`);
+  return lines.length > 0 ? lines.join("\n") : null;
+}
+function formatHumanEvaluations(evals) {
+  if (evals.length === 0) return null;
+  const total = evals.reduce((sum, e) => sum + e.rating, 0);
+  const avg = total / evals.length;
+  const label = avg > 0.3 ? "Helpful" : avg < -0.3 ? "Unhelpful" : "Neutral";
+  const lines = [
+    `- Overall: ${label} (avg ${avg.toFixed(2)}, ${evals.length} message${evals.length === 1 ? "" : "s"})`
+  ];
+  for (const e of evals) {
+    const ratingLabel = e.rating > 0 ? "helpful" : e.rating < 0 ? "unhelpful" : "neutral";
+    lines.push(`  - Message ${e.messageIndex}: ${ratingLabel} \u2014 ${e.reasoning}`);
+  }
+  return lines.join("\n");
+}
+function computeGradeCounts(turnGrades) {
+  const counts = {
+    planningCorrect: 0,
+    planningNeutral: 0,
+    planningBlunder: 0,
+    buildingCorrect: 0,
+    buildingNeutral: 0,
+    buildingBlunder: 0,
+    humanCorrect: 0,
+    humanNeutral: 0,
+    humanBlunder: 0
+  };
+  for (const tg of turnGrades) {
+    const key = `${tg.phase}${tg.grade.charAt(0).toUpperCase()}${tg.grade.slice(1)}`;
+    if (key in counts) {
+      counts[key]++;
+    }
+  }
+  return counts;
+}
+function addCosts(base, addition) {
+  if (base === null) return addition;
+  if (addition === null) return base;
+  return base + addition;
+}
+function buildErrorResult(projectId, requestId, taskId, error) {
+  return {
+    projectId,
+    requestId,
+    taskId,
+    summary: "",
+    turnGrades: [],
+    planningAccuracy: null,
+    buildingAccuracy: null,
+    humanAccuracy: null,
+    planningCorrect: 0,
+    planningNeutral: 0,
+    planningBlunder: 0,
+    buildingCorrect: 0,
+    buildingNeutral: 0,
+    buildingBlunder: 0,
+    humanCorrect: 0,
+    humanNeutral: 0,
+    humanBlunder: 0,
+    suggestionIds: [],
+    auditCostUsd: null,
+    model: null,
+    error
+  };
+}
+function extractJsonBlock(text) {
+  const codeBlockMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)```/);
+  const jsonStr = codeBlockMatch ? codeBlockMatch[1].trim() : text;
+  try {
+    const parsed = JSON.parse(jsonStr);
+    if (parsed && typeof parsed === "object") return parsed;
+  } catch {
+  }
+  const objectMatch = text.match(/\{[\s\S]*\}/);
+  if (objectMatch) {
+    try {
+      const parsed = JSON.parse(objectMatch[0]);
+      if (parsed && typeof parsed === "object") return parsed;
+    } catch {
+    }
+  }
+  throw new Error("Could not parse JSON from Claude response");
+}
+function extractGradingResult(text, phase) {
+  const parsed = extractJsonBlock(text);
+  const turnGrades = Array.isArray(parsed.turnGrades) ? parsed.turnGrades.map((tg) => ({ ...tg, phase })) : [];
+  const summary = parsed.summary ?? "";
+  const accuracy = typeof parsed.accuracy === "number" ? parsed.accuracy : null;
+  return { turnGrades, summary, accuracy };
+}
+function extractHumanResult(text) {
+  const parsed = extractJsonBlock(text);
+  const humanEvaluations = Array.isArray(parsed.humanEvaluations) ? parsed.humanEvaluations : [];
+  const summary = parsed.summary ?? "";
+  const humanAccuracy = typeof parsed.humanAccuracy === "number" ? parsed.humanAccuracy : null;
+  return { humanEvaluations, summary, humanAccuracy };
+}
+function extractAnalysisResult(text) {
+  const parsed = extractJsonBlock(text);
+  const summary = parsed.summary ?? "";
+  const macro = parsed.macroEvaluation;
+  return {
+    summary,
+    macroEvaluation: macro ? {
+      instructionsQuality: macro.instructionsQuality ?? void 0,
+      modelSuitability: macro.modelSuitability ?? void 0,
+      contextAndPlanning: macro.contextAndPlanning ?? void 0,
+      overallResult: macro.overallResult ?? void 0
+    } : null
+  };
+}
+function buildMergedSummary(planningResult, buildingResult, humanResult, analysisResult) {
+  const summaryParts = [];
+  if (analysisResult?.summary) {
+    summaryParts.push(analysisResult.summary);
+  } else {
+    if (planningResult?.summary) summaryParts.push(`Planning: ${planningResult.summary}`);
+    if (buildingResult?.summary) summaryParts.push(`Building: ${buildingResult.summary}`);
+    if (humanResult?.summary) summaryParts.push(`Human: ${humanResult.summary}`);
+  }
+  const macroText = analysisResult?.macroEvaluation ? formatMacroEvaluation(analysisResult.macroEvaluation) : null;
+  const humanEvalText = humanResult ? formatHumanEvaluations(humanResult.humanEvaluations) : null;
+  let summary = summaryParts.join("\n\n");
+  if (macroText) summary += `
+
+---
+
+Macro Evaluation:
+${macroText}`;
+  if (humanEvalText) summary += `
+
+---
+
+Human Contributions:
+${humanEvalText}`;
+  return summary;
+}
+function mergeStepResults(planningResult, buildingResult, humanResult, analysisResult, planningTraceLength) {
+  const planGrades = planningResult?.turnGrades ?? [];
+  const buildGrades = (buildingResult?.turnGrades ?? []).map((tg) => ({
+    ...tg,
+    turnIndex: tg.turnIndex + planningTraceLength
+  }));
+  return {
+    turnGrades: [...planGrades, ...buildGrades],
+    summary: buildMergedSummary(planningResult, buildingResult, humanResult, analysisResult),
+    planningAccuracy: planningResult?.accuracy ?? null,
+    buildingAccuracy: buildingResult?.accuracy ?? null,
+    humanAccuracy: humanResult?.humanAccuracy ?? null,
+    humanEvaluations: humanResult?.humanEvaluations ?? [],
+    macroEvaluation: analysisResult?.macroEvaluation ?? null
+  };
+}
+
+// src/runner/task-audit-trace-slicer.ts
+var PLAN_UPDATE_PATTERN = /mcp__conveyor__update_task$/;
+var PR_CREATION_PATTERN = /mcp__conveyor__create_pull_request$/;
+function eventMatchesTool(event, toolPattern) {
+  if (event.type === "tool_use" && typeof event.data.tool === "string") {
+    if (toolPattern.test(event.data.tool)) return true;
+  }
+  if (event.type === "turn_end" && Array.isArray(event.data.toolCalls)) {
+    for (const tc of event.data.toolCalls) {
+      if (typeof tc.tool === "string" && toolPattern.test(tc.tool)) return true;
+    }
+  }
+  return false;
+}
+function findLastToolCallIndex(trace, toolPattern) {
+  for (let i = trace.length - 1; i >= 0; i--) {
+    if (eventMatchesTool(trace[i], toolPattern)) return i;
+  }
+  return -1;
+}
+function sliceTrace(trace) {
+  const lastPlanUpdateIndex = findLastToolCallIndex(trace, PLAN_UPDATE_PATTERN);
+  const lastPrCreationIndex = findLastToolCallIndex(trace, PR_CREATION_PATTERN);
+  const boundaries = { lastPlanUpdateIndex, lastPrCreationIndex };
+  if (lastPlanUpdateIndex === -1 && lastPrCreationIndex === -1) {
+    return { planningTrace: [], buildingTrace: trace, boundaries };
+  }
+  if (lastPlanUpdateIndex === -1) {
+    return {
+      planningTrace: [],
+      buildingTrace: lastPrCreationIndex >= 0 ? trace.slice(0, lastPrCreationIndex + 1) : trace,
+      boundaries
+    };
+  }
+  const planEnd = lastPrCreationIndex >= 0 && lastPlanUpdateIndex > lastPrCreationIndex ? lastPrCreationIndex : lastPlanUpdateIndex;
+  const planningTrace = trace.slice(0, planEnd + 1);
+  const buildEnd = lastPrCreationIndex >= 0 ? lastPrCreationIndex + 1 : trace.length;
+  const buildingTrace = trace.slice(planEnd + 1, buildEnd);
+  return { planningTrace, buildingTrace, boundaries };
+}
+
+// src/runner/task-audit-prompts.ts
+var PLANNING_AUDIT_SYSTEM_PROMPT = `You are a chess-style analysis engine grading the PLANNING phase of an AI agent's task execution. You receive only the planning portion of the agent's trace \u2014 from the start through the last plan update. Grade each turn objectively.
+
+## Grading Scale
+
+- **Correct** (\u265F): Sound moves toward understanding the task \u2014 reading relevant files, analyzing requirements, logical reasoning about approach, following project patterns
+- **Neutral** (\xB7): No significant positive or negative effect \u2014 exploratory reads, minor tangents
+- **Blunder** (??): Wasted effort \u2014 reading irrelevant files repeatedly, ignoring requirements, spending many turns without making progress toward a plan
+
+## Specific Blunder Examples
+- Reading the same file 5+ times without advancing understanding
+- Ignoring explicit task requirements or project conventions visible in the code
+- Spending many turns on tangential investigation not related to the task
+- Failing to read key files that are obvious from the task description
+
+## Specific Correct Examples
+- Reading context files before implementation
+- Analyzing requirements and dependencies systematically
+- Identifying relevant code patterns to follow
+- Building understanding incrementally
+
+## Output Format
+
+Output a JSON block:
+
+\`\`\`json
+{
+  "turnGrades": [
+    {
+      "turnIndex": 0,
+      "grade": "correct",
+      "reasoning": "Read relevant config files to understand project structure",
+      "eventType": "tool_use",
+      "eventSummary": "Read package.json and tsconfig.json"
+    }
+  ],
+  "summary": "Brief 2-3 sentence assessment of planning quality",
+  "accuracy": 0.85
+}
+\`\`\`
+
+**Accuracy Calculation**: accuracy = correct / (correct + blunder). Neutral turns are excluded. Return null if no correct or blunder turns exist.
+
+IMPORTANT: Do NOT include a "phase" field in turnGrades \u2014 the phase is set programmatically. Only include turnIndex, grade, reasoning, eventType, and eventSummary.`;
+var BUILDING_AUDIT_SYSTEM_PROMPT = `You are a chess-style analysis engine grading the BUILDING phase of an AI agent's task execution. You receive only the building portion of the agent's trace \u2014 from after the plan was finalized through pull request creation. Grade each turn objectively.
+
+## Grading Scale
+
+- **Correct** (\u265F): Sound implementation moves \u2014 proper edits, running tests, fixing errors, following plan steps, adapting to feedback
+- **Neutral** (\xB7): No significant positive or negative effect \u2014 exploratory reads during implementation, minor tangents
+- **Blunder** (??): Wasted effort \u2014 incorrect edits immediately reverted, repeated failures without adapting, ignoring the plan, using wrong APIs despite visible patterns
+
+## Specific Blunder Examples
+- Making edits that are immediately reverted or overwritten
+- Ignoring explicit plan steps or user corrections
+- Repeated failed tool calls (isError: true) without changing approach
+- Using wrong APIs despite project patterns visible in the trace
+- Spending many turns on tangential work not in the plan
+
+## Specific Correct Examples
+- Following plan steps in logical sequence
+- Proper error handling and recovery after tool failures
+- Adapting approach based on test results or errors
+- Efficient tool usage with clear purpose
+- Running tests to verify changes
+
+## Output Format
+
+Output a JSON block:
+
+\`\`\`json
+{
+  "turnGrades": [
+    {
+      "turnIndex": 0,
+      "grade": "correct",
+      "reasoning": "Implemented the required changes following the plan",
+      "eventType": "tool_use",
+      "eventSummary": "Edit src/component.tsx"
+    }
+  ],
+  "summary": "Brief 2-3 sentence assessment of building quality",
+  "accuracy": 0.72
+}
+\`\`\`
+
+**Accuracy Calculation**: accuracy = correct / (correct + blunder). Neutral turns are excluded. Return null if no correct or blunder turns exist.
+
+IMPORTANT: Turn indices are 0-based relative to the trace slice provided. Do NOT include a "phase" field \u2014 the phase is set programmatically. Only include turnIndex, grade, reasoning, eventType, and eventSummary.`;
+var HUMAN_AUDIT_SYSTEM_PROMPT = `You are evaluating human contributions to an AI agent's task execution. For each human message, assess whether it helped, hindered, or had no effect on the agent's work.
+
+## Rating Scale
+
+- **Helpful (+1)**: Provided useful context, clear corrections, actionable feedback, or unblocked the agent
+- **Neutral (0)**: Acknowledgements, status checks, or messages with no material impact on execution
+- **Unhelpful (-1)**: Contradictory instructions, incorrect guidance, unnecessary interruptions, or vague requests that caused wasted effort
+
+## Output Format
+
+Output a JSON block:
+
+\`\`\`json
+{
+  "humanEvaluations": [
+    {
+      "messageIndex": 0,
+      "rating": 1,
+      "reasoning": "Provided clear context about the bug with reproduction steps"
+    }
+  ],
+  "summary": "Brief 2-3 sentence assessment of human contributions",
+  "humanAccuracy": 0.75
+}
+\`\`\`
+
+**humanAccuracy Calculation**: humanAccuracy = helpful / (helpful + unhelpful). Neutral messages are excluded. Return null if no helpful or unhelpful messages exist.
+
+Evaluate EVERY human message \u2014 do not skip any. Each entry in humanEvaluations must have a messageIndex (0-based index into the Human Messages list), rating (+1, 0, or -1), and reasoning.`;
+var ANALYSIS_SYSTEM_PROMPT = `You are performing a macro-level analysis of an AI agent's task execution and generating improvement suggestions. You receive grading results from planning, building, and human evaluation phases.
+
+## Your Tasks
+
+1. **Write an overall summary** (2-4 sentences) that synthesizes the planning, building, and human evaluation findings into a cohesive assessment.
+
+2. **Perform a macro evaluation** addressing:
+   - **Instructions Quality**: Were the agent instructions appropriate? Too vague, too prescriptive, or missing critical guidance?
+   - **Model Suitability**: Was the model choice appropriate for the complexity of this task?
+   - **Context & Planning**: Was the plan/context sufficient? Were there information gaps that caused wasted effort?
+   - **Overall Result**: Did the final result meet requirements? Was the outcome proportional to effort?
+
+3. **Generate suggestions** using the create_suggestion tool. Focus on:
+   - Recurring patterns of wasted effort that could be prevented
+   - Missing documentation or context that caused confusion
+   - Process improvements to prevent common blunders
+   - What worked well that should be replicated
+
+You MUST call create_suggestion at least once. If the execution was flawless, suggest what made it work well so the pattern can be replicated.
+
+## Output Format
+
+After calling create_suggestion, output a JSON block:
+
+\`\`\`json
+{
+  "summary": "Overall 2-4 sentence assessment synthesizing all phases",
+  "macroEvaluation": {
+    "instructionsQuality": "Brief assessment of instruction quality",
+    "modelSuitability": "Brief assessment of model choice",
+    "contextAndPlanning": "Brief assessment of context and planning",
+    "overallResult": "Brief assessment of the outcome"
+  }
+}
+\`\`\``;
+function buildSessionInfoSection(info) {
+  const lines = ["## Session Info"];
+  if (info.model) lines.push(`- Model: ${info.model}`);
+  if (info.totalCostUsd !== null) lines.push(`- Total Cost: $${info.totalCostUsd.toFixed(4)}`);
+  if (info.planningTurns !== null) lines.push(`- Planning Turns: ${info.planningTurns}`);
+  if (info.buildingTurns !== null) lines.push(`- Building Turns: ${info.buildingTurns}`);
+  if (info.locDiff !== null) lines.push(`- Lines Changed: ${info.locDiff}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function buildTraceSection(trace) {
+  const lines = ["## Agent Trace\n"];
+  if (trace.length === 0) {
+    lines.push("No agent trace data available.\n");
+  } else {
+    for (let i = 0; i < trace.length; i++) {
+      const event = trace[i];
+      const dataStr = JSON.stringify(event.data);
+      const truncated = dataStr.length > 2e3 ? dataStr.slice(0, 2e3) + "..." : dataStr;
+      lines.push(`### Turn ${i} [${event.type}] @ ${event.timestamp}`);
+      lines.push(truncated);
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function buildTaskContextSection(task) {
+  const parts = [];
+  if (task.taskDescription) parts.push(`## Description
+${task.taskDescription}
+`);
+  if (task.taskPlan) parts.push(`## Plan
+${task.taskPlan}
+`);
+  parts.push(`## Task Status: ${task.taskStatus}`);
+  if (task.storyPointValue !== null) parts.push(`## Story Points: ${task.storyPointValue}`);
+  parts.push("");
+  if (task.sessionInfo) parts.push(buildSessionInfoSection(task.sessionInfo));
+  if (task.agentInstructions) parts.push(`## Agent Instructions
+${task.agentInstructions}
+`);
+  return parts.join("\n");
+}
+function buildPlanningAuditPrompt(task, planningTrace) {
+  const parts = [`# Planning Audit: ${task.taskTitle}
+`];
+  parts.push(buildTaskContextSection(task));
+  parts.push(buildTraceSection(planningTrace));
+  parts.push("Grade each turn above, then output the structured JSON result.");
+  return parts.join("\n");
+}
+function buildBuildingAuditPrompt(task, buildingTrace) {
+  const parts = [`# Building Audit: ${task.taskTitle}
+`];
+  parts.push(buildTaskContextSection(task));
+  parts.push(buildTraceSection(buildingTrace));
+  parts.push("Grade each turn above, then output the structured JSON result.");
+  return parts.join("\n");
+}
+function buildHumanAuditPrompt(task) {
+  const parts = [`# Human Contribution Evaluation: ${task.taskTitle}
+`];
+  if (task.taskDescription) parts.push(`## Description
+${task.taskDescription}
+`);
+  if (task.taskPlan) parts.push(`## Plan
+${task.taskPlan}
+`);
+  parts.push(`## Task Status: ${task.taskStatus}
+`);
+  parts.push("## Human Messages\n");
+  for (let i = 0; i < task.humanMessages.length; i++) {
+    const msg = task.humanMessages[i];
+    parts.push(`### Message ${i} [${msg.createdAt}]`);
+    parts.push(`**${msg.role}**: ${msg.content}
+`);
+  }
+  parts.push("Evaluate each human message above, then output the structured JSON result.");
+  return parts.join("\n");
+}
+function buildGradingResultSection(label, result) {
+  const grades = result.turnGrades;
+  const correct = grades.filter((g) => g.grade === "correct").length;
+  const neutral = grades.filter((g) => g.grade === "neutral").length;
+  const blunder = grades.filter((g) => g.grade === "blunder").length;
+  const accuracy = result.accuracy === null ? "N/A" : result.accuracy.toFixed(2);
+  return [
+    `## ${label} Phase Results`,
+    `- Summary: ${result.summary}`,
+    `- Accuracy: ${accuracy}`,
+    `- ${grades.length} turns: ${correct} correct, ${neutral} neutral, ${blunder} blunders`,
+    ""
+  ].join("\n");
+}
+function buildAnalysisPrompt(task, planningResult, buildingResult, humanResult) {
+  const parts = [`# Task Analysis: ${task.taskTitle}
+`];
+  if (task.taskDescription) parts.push(`## Description
+${task.taskDescription}
+`);
+  if (task.taskPlan) parts.push(`## Plan
+${task.taskPlan}
+`);
+  parts.push(`## Task Status: ${task.taskStatus}`);
+  if (task.storyPointValue !== null) parts.push(`## Story Points: ${task.storyPointValue}`);
+  parts.push("");
+  if (task.sessionInfo) parts.push(buildSessionInfoSection(task.sessionInfo));
+  if (planningResult) parts.push(buildGradingResultSection("Planning", planningResult));
+  if (buildingResult) parts.push(buildGradingResultSection("Building", buildingResult));
+  if (humanResult) {
+    const evals = humanResult.humanEvaluations;
+    const helpful = evals.filter((e) => e.rating > 0).length;
+    const neutralCount = evals.filter((e) => e.rating === 0).length;
+    const unhelpful = evals.filter((e) => e.rating < 0).length;
+    parts.push("## Human Evaluation Results");
+    parts.push(`- Summary: ${humanResult.summary}`);
+    parts.push(
+      `- ${evals.length} messages: ${helpful} helpful, ${neutralCount} neutral, ${unhelpful} unhelpful`
+    );
+    parts.push("");
+  }
+  const allGrades = [...planningResult?.turnGrades ?? [], ...buildingResult?.turnGrades ?? []];
+  const blunders = allGrades.filter((g) => g.grade === "blunder");
+  if (blunders.length > 0) {
+    parts.push("## Notable Blunders");
+    for (const b of blunders.slice(0, 10)) {
+      parts.push(`- Turn ${b.turnIndex} (${b.phase}): ${b.reasoning}`);
+    }
+    parts.push("");
+  }
+  parts.push(
+    "Based on the findings above, call create_suggestion for each actionable improvement, then output the JSON result."
+  );
+  return parts.join("\n");
+}
+
+// src/runner/task-audit-progress.ts
+function reportProgress(connection, requestId, taskId, tool, input) {
+  void connection.call("reportTaskAuditProgress", {
+    projectId: connection.projectId,
+    requestId,
+    taskId,
+    activity: { tool, input, timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+  }).catch(() => {
+  });
+}
+function processAssistantBlocks(blocks, responseParts, ctx, reportedFirstText) {
+  for (const block of blocks) {
+    if (block.type === "text" && block.text) {
+      responseParts.push(block.text);
+      if (reportedFirstText.value) continue;
+      reportedFirstText.value = true;
+      reportProgress(
+        ctx.connection,
+        ctx.requestId,
+        ctx.taskId,
+        "thinking",
+        block.text.slice(0, 200)
+      );
+    } else if (block.type === "tool_use" && block.name) {
+      const inputStr = typeof block.input === "string" ? block.input : JSON.stringify(block.input);
+      reportProgress(ctx.connection, ctx.requestId, ctx.taskId, block.name, inputStr.slice(0, 500));
+    }
+  }
+}
+async function collectResponseFromEvents(events, connection, requestId, taskId) {
+  const responseParts = [];
+  let costUsd = null;
+  let model = null;
+  const reportedFirstText = { value: false };
+  const ctx = { connection, requestId, taskId };
+  for await (const event of events) {
+    if (event.type === "system") {
+      const sysEvent = event;
+      if (sysEvent.subtype === "init" && sysEvent.model) {
+        model = sysEvent.model;
+        reportProgress(
+          connection,
+          requestId,
+          taskId,
+          "system",
+          `Initialized model: ${sysEvent.model}`
+        );
+      }
+    }
+    if (event.type === "assistant") {
+      const { message } = event;
+      processAssistantBlocks(message.content, responseParts, ctx, reportedFirstText);
+    }
+    if (event.type === "result") {
+      const resultEvent = event;
+      if (resultEvent.subtype === "success" && resultEvent.total_cost_usd !== void 0) {
+        costUsd = resultEvent.total_cost_usd;
+      }
+      const status = resultEvent.subtype === "success" ? "success" : `error: ${resultEvent.subtype}`;
+      reportProgress(connection, requestId, taskId, "complete", status);
+      break;
+    }
+  }
+  return { text: responseParts.join("\n\n").trim(), costUsd, model };
+}
+
+// src/runner/task-audit-handler.ts
+var logger = createServiceLogger("TaskAudit");
+var FALLBACK_MODEL = "claude-sonnet-4-6";
+function buildProjectSuggestionTool(connection, projectId) {
+  return defineTool(
+    "create_suggestion",
+    "Suggest a cross-cutting improvement for the project based on patterns found during audit. If a similar suggestion exists, your vote is added instead of creating a duplicate.",
+    {
+      title: z.string().describe("Short title for the suggestion"),
+      description: z.string().optional().describe("Details about the suggestion"),
+      tag_names: z.array(z.string()).optional().describe("Tag names to categorize the suggestion")
+    },
+    async ({ title, description, tag_names }) => {
+      try {
+        const result = await connection.call("createProjectSuggestion", {
+          projectId,
+          title,
+          description,
+          tagNames: tag_names
+        });
+        if (result.merged) {
+          return textResult(
+            `Merged into existing suggestion (ID: ${result.mergedIntoId ?? result.id}).`
+          );
+        }
+        return textResult(`Suggestion created (ID: ${result.id}).`);
+      } catch (error) {
+        return textResult(
+          `Failed to create suggestion: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    }
+  );
+}
+function buildTrackedSuggestionTool(connection, projectId, suggestionIds) {
+  const suggestionTool = buildProjectSuggestionTool(connection, projectId);
+  return defineTool(
+    suggestionTool.name,
+    suggestionTool.description,
+    suggestionTool.schema,
+    async (input) => {
+      const result = await suggestionTool.handler(input);
+      const text = result.content?.[0]?.text ?? "";
+      const idMatch = text.match(/ID: ([a-z0-9]+)/i);
+      if (idMatch) suggestionIds.push(idMatch[1]);
+      return result;
+    }
+  );
+}
+async function fetchModel(connection) {
+  try {
+    const ctx = await connection.call("getProjectAgentContextByRole", {
+      projectId: connection.projectId,
+      role: "reviewer"
+    });
+    return ctx.model || FALLBACK_MODEL;
+  } catch {
+    return FALLBACK_MODEL;
+  }
+}
+function buildQueryOptions(systemPrompt, opts, limits, mcpServers = {}) {
+  return {
+    model: opts.model,
+    systemPrompt,
+    cwd: opts.projectDir,
+    permissionMode: "bypassPermissions",
+    allowDangerouslySkipPermissions: true,
+    tools: { type: "preset", preset: "claude_code" },
+    mcpServers,
+    maxTurns: limits.maxTurns,
+    maxBudgetUsd: limits.maxBudgetUsd,
+    disallowedTools: ["Edit", "Write", "Bash", "NotebookEdit", "MultiEdit"]
+  };
+}
+async function runGradingStep(taskId, phase, systemPrompt, userPrompt, limits, opts) {
+  const harness = createHarness();
+  const events = harness.executeQuery({
+    prompt: userPrompt,
+    options: buildQueryOptions(systemPrompt, opts, limits)
+  });
+  const response = await collectResponseFromEvents(events, opts.connection, opts.requestId, taskId);
+  if (!response.text) throw new Error(`No response from ${phase} grading step`);
+  return {
+    result: extractGradingResult(response.text, phase),
+    costUsd: response.costUsd,
+    model: response.model
+  };
+}
+async function runHumanStep(taskId, userPrompt, limits, opts) {
+  const harness = createHarness();
+  const events = harness.executeQuery({
+    prompt: userPrompt,
+    options: buildQueryOptions(HUMAN_AUDIT_SYSTEM_PROMPT, opts, limits)
+  });
+  const response = await collectResponseFromEvents(events, opts.connection, opts.requestId, taskId);
+  if (!response.text) throw new Error("No response from human evaluation step");
+  return { result: extractHumanResult(response.text), costUsd: response.costUsd };
+}
+async function runAnalysisStep(task, planningResult, buildingResult, humanResult, projectId, suggestionIds, opts) {
+  const wrappedTool = buildTrackedSuggestionTool(opts.connection, projectId, suggestionIds);
+  const harness = createHarness();
+  const mcpServer = harness.createMcpServer({ name: "conveyor", tools: [wrappedTool] });
+  const events = harness.executeQuery({
+    prompt: buildAnalysisPrompt(task, planningResult, buildingResult, humanResult),
+    options: buildQueryOptions(
+      ANALYSIS_SYSTEM_PROMPT,
+      opts,
+      { maxTurns: 6, maxBudgetUsd: 1 },
+      { conveyor: mcpServer }
+    )
+  });
+  const response = await collectResponseFromEvents(
+    events,
+    opts.connection,
+    opts.requestId,
+    task.taskId
+  );
+  if (!response.text) throw new Error("No response from analysis step");
+  return { result: extractAnalysisResult(response.text), costUsd: response.costUsd };
+}
+var EMPTY_STEP = { result: null, costUsd: null, model: null };
+var GRADING_LIMITS = { maxTurns: 8, maxBudgetUsd: 1 };
+async function executeStepSafely(stepLabel, requestId, taskId, fn) {
+  try {
+    const step = await fn();
+    return { result: step.result, costUsd: step.costUsd, model: step.model ?? null };
+  } catch (err) {
+    logger.warn(`${stepLabel} failed`, {
+      requestId,
+      taskId,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return EMPTY_STEP;
+  }
+}
+async function executePlanningStep(taskPayload, planningTrace, opts) {
+  if (planningTrace.length === 0) return EMPTY_STEP;
+  reportProgress(
+    opts.connection,
+    opts.requestId,
+    taskPayload.taskId,
+    "status",
+    "Step 1/4: Auditing planning..."
+  );
+  return await executeStepSafely(
+    "Planning audit",
+    opts.requestId,
+    taskPayload.taskId,
+    () => runGradingStep(
+      taskPayload.taskId,
+      "planning",
+      PLANNING_AUDIT_SYSTEM_PROMPT,
+      buildPlanningAuditPrompt(taskPayload, planningTrace),
+      GRADING_LIMITS,
+      opts
+    )
+  );
+}
+async function executeBuildingStep(taskPayload, buildingTrace, opts) {
+  if (buildingTrace.length === 0) return EMPTY_STEP;
+  reportProgress(
+    opts.connection,
+    opts.requestId,
+    taskPayload.taskId,
+    "status",
+    "Step 2/4: Auditing building..."
+  );
+  return await executeStepSafely(
+    "Building audit",
+    opts.requestId,
+    taskPayload.taskId,
+    () => runGradingStep(
+      taskPayload.taskId,
+      "building",
+      BUILDING_AUDIT_SYSTEM_PROMPT,
+      buildBuildingAuditPrompt(taskPayload, buildingTrace),
+      GRADING_LIMITS,
+      opts
+    )
+  );
+}
+async function executeHumanStep(taskPayload, opts) {
+  if (taskPayload.humanMessages.length === 0) return EMPTY_STEP;
+  reportProgress(
+    opts.connection,
+    opts.requestId,
+    taskPayload.taskId,
+    "status",
+    "Step 3/4: Auditing human contributions..."
+  );
+  return await executeStepSafely(
+    "Human audit",
+    opts.requestId,
+    taskPayload.taskId,
+    () => runHumanStep(
+      taskPayload.taskId,
+      buildHumanAuditPrompt(taskPayload),
+      { maxTurns: 6, maxBudgetUsd: 0.5 },
+      opts
+    )
+  );
+}
+async function executeAnalysisStep(taskPayload, planning, building, human, projectId, suggestionIds, opts) {
+  reportProgress(
+    opts.connection,
+    opts.requestId,
+    taskPayload.taskId,
+    "status",
+    "Step 4/4: Generating analysis & suggestions..."
+  );
+  return await executeStepSafely(
+    "Analysis",
+    opts.requestId,
+    taskPayload.taskId,
+    () => runAnalysisStep(
+      taskPayload,
+      planning.result,
+      building.result,
+      human.result,
+      projectId,
+      suggestionIds,
+      opts
+    )
+  );
+}
+async function reportAuditResult(connection, requestId, taskPayload, steps, planningTraceLength, suggestionIds) {
+  let totalCostUsd = null;
+  for (const step of [steps.planning, steps.building, steps.human, steps.analysis])
+    totalCostUsd = addCosts(totalCostUsd, step.costUsd);
+  const merged = mergeStepResults(
+    steps.planning.result,
+    steps.building.result,
+    steps.human.result,
+    steps.analysis.result,
+    planningTraceLength
+  );
+  await connection.call("reportTaskAuditResult", {
+    projectId: connection.projectId,
+    requestId,
+    taskId: taskPayload.taskId,
+    summary: merged.summary,
+    turnGrades: merged.turnGrades,
+    planningAccuracy: merged.planningAccuracy,
+    buildingAccuracy: merged.buildingAccuracy,
+    humanAccuracy: merged.humanAccuracy,
+    humanEvaluations: merged.humanEvaluations,
+    ...computeGradeCounts(merged.turnGrades),
+    suggestionIds,
+    auditCostUsd: totalCostUsd,
+    model: steps.planning.model ?? steps.building.model ?? null
+  });
+}
+async function auditSingleTask(taskPayload, request, connection, projectDir, model) {
+  const { requestId, projectId } = request;
+  const suggestionIds = [];
+  const opts = { connection, requestId, projectDir, model };
+  const { planningTrace, buildingTrace } = sliceTrace(taskPayload.agentTrace);
+  const planning = await executePlanningStep(taskPayload, planningTrace, opts);
+  const building = await executeBuildingStep(taskPayload, buildingTrace, opts);
+  if (!planning.result && !building.result && (planningTrace.length > 0 || buildingTrace.length > 0)) {
+    throw new Error("All grading audit steps failed");
+  }
+  const human = await executeHumanStep(taskPayload, opts);
+  const analysis = await executeAnalysisStep(
+    taskPayload,
+    planning,
+    building,
+    human,
+    projectId,
+    suggestionIds,
+    opts
+  );
+  await reportAuditResult(
+    connection,
+    requestId,
+    taskPayload,
+    { planning, building, human, analysis },
+    planningTrace.length,
+    suggestionIds
+  );
+  logger.info("Task audit complete", {
+    requestId,
+    taskId: taskPayload.taskId,
+    suggestions: suggestionIds.length
+  });
+}
+async function handleTaskAudit(request, connection, projectDir) {
+  const { requestId } = request;
+  logger.info("Starting task audit", { requestId, taskCount: request.tasks.length });
+  const model = await fetchModel(connection);
+  for (const taskPayload of request.tasks) {
+    try {
+      await auditSingleTask(taskPayload, request, connection, projectDir, model);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger.error("Task audit failed for task", {
+        requestId,
+        taskId: taskPayload.taskId,
+        error: msg
+      });
+      await connection.call(
+        "reportTaskAuditResult",
+        buildErrorResult(connection.projectId, requestId, taskPayload.taskId, msg)
+      ).catch(() => {
+      });
+    }
+  }
+  await connection.call("reportTaskAuditBatchComplete", { projectId: connection.projectId, requestId }).catch(() => {
+  });
+}
+export {
+  handleTaskAudit
+};
+//# sourceMappingURL=task-audit-handler-6TZRN3YB.js.map