@rallycry/conveyor-agent 8.12.0 → 9.0.0

package/dist/task-audit-handler-BRCXB5V6.js

@@ -1,801 +0,0 @@
-import {
-  textResult
-} from "./chunk-FDWECEDJ.js";
-import {
-  createHarness,
-  createServiceLogger,
-  defineTool
-} from "./chunk-TN2YYT2V.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");
-}
-var VALID_GRADING_PHASES = /* @__PURE__ */ new Set(["planning", "building"]);
-function extractCombinedGradingResult(text) {
-  const parsed = extractJsonBlock(text);
-  const turnGrades = Array.isArray(parsed.turnGrades) ? parsed.turnGrades.map((tg) => ({
-    ...tg,
-    phase: VALID_GRADING_PHASES.has(tg.phase) ? tg.phase : "building"
-  })) : [];
-  const summary = parsed.summary ?? "";
-  const planningAccuracy = typeof parsed.planningAccuracy === "number" ? parsed.planningAccuracy : null;
-  const buildingAccuracy = typeof parsed.buildingAccuracy === "number" ? parsed.buildingAccuracy : null;
-  return { turnGrades, summary, planningAccuracy, buildingAccuracy };
-}
-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(gradingResult, humanResult, analysisResult) {
-  const summaryParts = [];
-  if (analysisResult?.summary) {
-    summaryParts.push(analysisResult.summary);
-  } else {
-    if (gradingResult?.summary) summaryParts.push(gradingResult.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(gradingResult, humanResult, analysisResult) {
-  const agentGrades = gradingResult?.turnGrades ?? [];
-  const humanGrades = (humanResult?.humanEvaluations ?? []).map((e) => ({
-    turnIndex: e.messageIndex,
-    phase: "human",
-    grade: e.rating > 0 ? "correct" : e.rating < 0 ? "blunder" : "neutral",
-    reasoning: e.reasoning,
-    eventType: "human_message",
-    eventSummary: `Message ${e.messageIndex}`
-  }));
-  return {
-    turnGrades: [...agentGrades, ...humanGrades],
-    summary: buildMergedSummary(gradingResult, humanResult, analysisResult),
-    planningAccuracy: gradingResult?.planningAccuracy ?? null,
-    buildingAccuracy: gradingResult?.buildingAccuracy ?? null,
-    humanAccuracy: humanResult?.humanAccuracy ?? null,
-    humanEvaluations: humanResult?.humanEvaluations ?? [],
-    macroEvaluation: analysisResult?.macroEvaluation ?? null
-  };
-}
-
-// src/runner/task-audit-prompts.ts
-var COMBINED_GRADING_SYSTEM_PROMPT = `You are a chess-style analysis engine performing a holistic audit of an AI agent's full task execution \u2014 from initial planning through final implementation. You receive the complete agent trace covering all phases and sessions. Grade each turn objectively.
-
-## Phase Identification
-
-Identify the boundary between planning and building phases:
-- **Planning phase**: Turns from the start through the last \`update_task_plan\` (plan save) call. Includes reading requirements, exploring code, analyzing dependencies, and formulating the plan.
-- **Building phase**: Turns after the last plan save through PR creation (or end of trace). Includes implementation, testing, and PR creation.
-- If no \`update_task_plan\` call is found, treat all turns as building phase.
-
-You MUST label each turn with \`"phase": "planning"\` or \`"phase": "building"\`.
-
-## Multi-Session Awareness
-
-The trace may contain multiple agent sessions (indicated by \`session_manifest\` events). Grade ALL sessions \u2014 earlier sessions often contain valuable planning work or reflect restart patterns worth evaluating. If an earlier session was abandoned, grade its turns based on quality (exploration reads may be neutral, repeated failures may be blunders).
-
-## Grading Scale
-
-### Planning Turns
-- **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
-
-### Building Turns
-- **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
-
-## Output Format
-
-Output a JSON block:
-
-\`\`\`json
-{
-  "turnGrades": [
-    {
-      "turnIndex": 0,
-      "phase": "planning",
-      "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 holistic assessment of the full execution",
-  "planningAccuracy": 0.85,
-  "buildingAccuracy": 0.72
-}
-\`\`\`
-
-**Accuracy Calculation**: For each phase separately: accuracy = correct / (correct + blunder). Neutral turns are excluded. Return null for a phase if it has no correct or blunder turns.
-
-Turn indices are 0-based relative to the full trace provided. Every turn grade MUST include the phase field.`;
-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
-
-Suggestion guidelines:
-- Keep titles short and actionable (e.g. "Add error handling docs for payment service")
-- Keep descriptions to 1-2 sentences max \u2014 what should change and why
-- Be project-focused: describe what the PROJECT should change, not what happened in this task
-- Never reference specific task details, agent behavior, accuracy scores, or execution phases
-- If this task revealed a general project improvement, frame it as a standalone recommendation anyone could understand without task context
-
-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 buildMultiSessionNote(task) {
-  const count = task.sessionInfo?.sessionCount;
-  if (!count || count <= 1) return null;
-  return `> **Note:** This task had ${count} total agent sessions. All sessions are included in the trace below.
-`;
-}
-function buildCombinedGradingPrompt(task) {
-  const parts = [`# Full Workflow Audit: ${task.taskTitle}
-`];
-  const sessionNote = buildMultiSessionNote(task);
-  if (sessionNote) parts.push(sessionNote);
-  parts.push(buildTaskContextSection(task));
-  parts.push(buildTraceSection(task.agentTrace));
-  parts.push(
-    "Grade each turn above with its phase (planning or building), 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 buildPhaseResultSection(label, grades, accuracy, summary) {
-  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 accuracyStr = accuracy === null ? "N/A" : accuracy.toFixed(2);
-  return [
-    `## ${label} Phase Results`,
-    `- Summary: ${summary}`,
-    `- Accuracy: ${accuracyStr}`,
-    `- ${grades.length} turns: ${correct} correct, ${neutral} neutral, ${blunder} blunders`,
-    ""
-  ].join("\n");
-}
-function buildAnalysisPrompt(task, gradingResult, 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 (gradingResult) {
-    const planGrades = gradingResult.turnGrades.filter((g) => g.phase === "planning");
-    const buildGrades = gradingResult.turnGrades.filter((g) => g.phase === "building");
-    if (planGrades.length > 0) {
-      parts.push(
-        buildPhaseResultSection(
-          "Planning",
-          planGrades,
-          gradingResult.planningAccuracy,
-          gradingResult.summary
-        )
-      );
-    }
-    if (buildGrades.length > 0) {
-      parts.push(
-        buildPhaseResultSection(
-          "Building",
-          buildGrades,
-          gradingResult.buildingAccuracy,
-          gradingResult.summary
-        )
-      );
-    }
-  }
-  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 blunders = (gradingResult?.turnGrades ?? []).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 buildTrackedSuggestionTool(connection, projectId, suggestionIds) {
-  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(
-        "1-2 sentence description of what the project should change and why. Keep concise and task-agnostic."
-      )
-    },
-    async ({ title, description }) => {
-      try {
-        const result = await connection.call("createProjectSuggestion", {
-          projectId,
-          title,
-          description
-        });
-        const id = result.mergedIntoId ?? result.id;
-        if (id) {
-          suggestionIds.push(id);
-          logger.info("Suggestion tracked", { id, merged: result.merged });
-        }
-        if (result.merged) {
-          return textResult(`Merged into existing suggestion (ID: ${id}).`);
-        }
-        return textResult(`Suggestion created (ID: ${result.id}).`);
-      } catch (error) {
-        logger.warn("Suggestion creation failed", {
-          error: error instanceof Error ? error.message : String(error)
-        });
-        return textResult(
-          `Failed to create suggestion: ${error instanceof Error ? error.message : "Unknown error"}`
-        );
-      }
-    }
-  );
-}
-async function fetchModel(connection) {
-  try {
-    const config = await connection.call("getProjectFunctionConfig", {
-      projectId: connection.projectId,
-      functionId: "taskAudit"
-    });
-    return config.model || FALLBACK_MODEL;
-  } catch {
-    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 runCombinedGradingStep(taskId, userPrompt, limits, opts) {
-  const harness = createHarness();
-  const events = harness.executeQuery({
-    prompt: userPrompt,
-    options: buildQueryOptions(COMBINED_GRADING_SYSTEM_PROMPT, opts, limits)
-  });
-  const response = await collectResponseFromEvents(events, opts.connection, opts.requestId, taskId);
-  if (!response.text) throw new Error("No response from combined grading step");
-  return {
-    result: extractCombinedGradingResult(response.text),
-    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, gradingResult, 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, gradingResult, 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: 24, maxBudgetUsd: 3 };
-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 executeCombinedGradingStep(taskPayload, opts) {
-  if (taskPayload.agentTrace.length === 0) return EMPTY_STEP;
-  reportProgress(
-    opts.connection,
-    opts.requestId,
-    taskPayload.taskId,
-    "status",
-    "Step 1/3: Auditing full workflow..."
-  );
-  return await executeStepSafely(
-    "Combined grading audit",
-    opts.requestId,
-    taskPayload.taskId,
-    () => runCombinedGradingStep(
-      taskPayload.taskId,
-      buildCombinedGradingPrompt(taskPayload),
-      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 2/3: 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, grading, human, projectId, suggestionIds, opts) {
-  reportProgress(
-    opts.connection,
-    opts.requestId,
-    taskPayload.taskId,
-    "status",
-    "Step 3/3: Generating analysis & suggestions..."
-  );
-  return await executeStepSafely(
-    "Analysis",
-    opts.requestId,
-    taskPayload.taskId,
-    () => runAnalysisStep(taskPayload, grading.result, human.result, projectId, suggestionIds, opts)
-  );
-}
-async function reportAuditResult(connection, requestId, taskPayload, steps, suggestionIds) {
-  let totalCostUsd = null;
-  for (const step of [steps.grading, steps.human, steps.analysis])
-    totalCostUsd = addCosts(totalCostUsd, step.costUsd);
-  const merged = mergeStepResults(steps.grading.result, steps.human.result, steps.analysis.result);
-  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.grading.model ?? null
-  });
-}
-async function auditSingleTask(taskPayload, request, connection, projectDir, model) {
-  const { requestId, projectId } = request;
-  const suggestionIds = [];
-  const opts = { connection, requestId, projectDir, model };
-  const grading = await executeCombinedGradingStep(taskPayload, opts);
-  if (!grading.result && taskPayload.agentTrace.length > 0) {
-    throw new Error("Grading audit step failed");
-  }
-  const human = await executeHumanStep(taskPayload, opts);
-  const analysis = await executeAnalysisStep(
-    taskPayload,
-    grading,
-    human,
-    projectId,
-    suggestionIds,
-    opts
-  );
-  await reportAuditResult(
-    connection,
-    requestId,
-    taskPayload,
-    { grading, human, analysis },
-    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-BRCXB5V6.js.map