@rallycry/conveyor-agent 7.2.9 → 7.2.11

package/dist/cli.js

@@ -5,7 +5,7 @@ import {
   loadConveyorConfig,
   runSetupCommand,
   runStartCommand
-} from "./chunk-INNHAWJK.js";
+} from "./chunk-JYSWXYG6.js";
 import "./chunk-C5YAMQJ2.js";
 import {
   createServiceLogger

package/dist/index.d.ts

@@ -100,9 +100,6 @@ declare class AgentConnection {
     triggerIdentification(): Promise<{
         identified: boolean;
     }>;
-    requestScaleUp(tier: string, reason?: string): Promise<{
-        scaled: boolean;
-    }>;
     refreshAuthToken(): Promise<boolean>;
     sendEvent(event: Record<string, unknown>): void;
     flushEvents(): Promise<void>;

package/dist/index.js

@@ -24,7 +24,7 @@ import {
   runStartCommand,
   stageAndCommit,
   updateRemoteToken
-} from "./chunk-INNHAWJK.js";
+} from "./chunk-JYSWXYG6.js";
 import "./chunk-C5YAMQJ2.js";
 import "./chunk-RRXX6DTB.js";
 

package/dist/{task-audit-handler-Z3TBS4EN.js → task-audit-handler-6XWYK6KZ.js}

@@ -102,12 +102,17 @@ function extractJsonBlock(text) {
   }
   throw new Error("Could not parse JSON from Claude response");
 }
-function extractGradingResult(text, phase) {
+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 })) : [];
+  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 accuracy = typeof parsed.accuracy === "number" ? parsed.accuracy : null;
-  return { turnGrades, summary, accuracy };
+  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);
@@ -130,13 +135,12 @@ function extractAnalysisResult(text) {
     } : null
   };
 }
-function buildMergedSummary(planningResult, buildingResult, humanResult, analysisResult) {
+function buildMergedSummary(gradingResult, 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 (gradingResult?.summary) summaryParts.push(gradingResult.summary);
     if (humanResult?.summary) summaryParts.push(`Human: ${humanResult.summary}`);
   }
   const macroText = analysisResult?.macroEvaluation ? formatMacroEvaluation(analysisResult.macroEvaluation) : null;
@@ -156,144 +160,46 @@ 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
-  }));
+function mergeStepResults(gradingResult, humanResult, analysisResult) {
   return {
-    turnGrades: [...planGrades, ...buildGrades],
-    summary: buildMergedSummary(planningResult, buildingResult, humanResult, analysisResult),
-    planningAccuracy: planningResult?.accuracy ?? null,
-    buildingAccuracy: buildingResult?.accuracy ?? null,
+    turnGrades: gradingResult?.turnGrades ?? [],
+    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-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 trimToLastSession(trace) {
-  let lastManifestIndex = -1;
-  for (let i = trace.length - 1; i >= 0; i--) {
-    if (trace[i].type === "session_manifest") {
-      lastManifestIndex = i;
-      break;
-    }
-  }
-  if (lastManifestIndex <= 0) return trace;
-  return trace.slice(lastManifestIndex);
-}
-function findLastToolCallIndex(trace, toolPattern) {
-  for (let i = trace.length - 1; i >= 0; i--) {
-    if (eventMatchesTool(trace[i], toolPattern)) return i;
-  }
-  return -1;
-}
-function sliceTrace(rawTrace) {
-  const trace = trimToLastSession(rawTrace);
-  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.
+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.
 
-## Grading Scale
+## Phase Identification
 
-- **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
+Identify the boundary between planning and building phases:
+- **Planning phase**: Turns from the start through the last \`update_task\` (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\` call is found, treat all turns as building phase.
 
-## 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
+You MUST label each turn with \`"phase": "planning"\` or \`"phase": "building"\`.
 
-## Specific Correct Examples
-- Reading context files before implementation
-- Analyzing requirements and dependencies systematically
-- Identifying relevant code patterns to follow
-- Building understanding incrementally
+## Multi-Session Awareness
 
-## 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.
+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
 
-## 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
-
-**Multi-session awareness**: If the trace begins with exploration (reads/greps) before any edits, and there is no prior planning trace, these likely represent the agent re-orienting in a new session. Grade initial orientation reads as neutral unless clearly wasteful (e.g., reading the same file 5+ times).
-
-## 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:
@@ -303,20 +209,22 @@ Output a JSON block:
   "turnGrades": [
     {
       "turnIndex": 0,
+      "phase": "planning",
       "grade": "correct",
-      "reasoning": "Implemented the required changes following the plan",
+      "reasoning": "Read relevant config files to understand project structure",
       "eventType": "tool_use",
-      "eventSummary": "Edit src/component.tsx"
+      "eventSummary": "Read package.json and tsconfig.json"
     }
   ],
-  "summary": "Brief 2-3 sentence assessment of building quality",
-  "accuracy": 0.72
+  "summary": "Brief 2-3 sentence holistic assessment of the full execution",
+  "planningAccuracy": 0.85,
+  "buildingAccuracy": 0.72
 }
 \`\`\`
 
-**Accuracy Calculation**: accuracy = correct / (correct + blunder). Neutral turns are excluded. Return null if no correct or blunder turns exist.
+**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.
 
-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.`;
+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
@@ -427,27 +335,19 @@ ${task.agentInstructions}
 function buildMultiSessionNote(task) {
   const count = task.sessionInfo?.sessionCount;
   if (!count || count <= 1) return null;
-  return `> **Note:** This task had ${count} total agent sessions. The trace below represents only the final session. Prior sessions were filtered out.
+  return `> **Note:** This task had ${count} total agent sessions. All sessions are included in the trace below.
 `;
 }
-function buildPlanningAuditPrompt(task, planningTrace) {
-  const parts = [`# Planning Audit: ${task.taskTitle}
-`];
-  const sessionNote = buildMultiSessionNote(task);
-  if (sessionNote) parts.push(sessionNote);
-  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}
+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(buildingTrace));
-  parts.push("Grade each turn above, then output the structured JSON result.");
+  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) {
@@ -471,21 +371,20 @@ ${task.taskPlan}
   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;
+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 accuracy = result.accuracy === null ? "N/A" : result.accuracy.toFixed(2);
+  const accuracyStr = accuracy === null ? "N/A" : accuracy.toFixed(2);
   return [
     `## ${label} Phase Results`,
-    `- Summary: ${result.summary}`,
-    `- Accuracy: ${accuracy}`,
+    `- Summary: ${summary}`,
+    `- Accuracy: ${accuracyStr}`,
     `- ${grades.length} turns: ${correct} correct, ${neutral} neutral, ${blunder} blunders`,
     ""
   ].join("\n");
 }
-function buildAnalysisPrompt(task, planningResult, buildingResult, humanResult) {
+function buildAnalysisPrompt(task, gradingResult, humanResult) {
   const parts = [`# Task Analysis: ${task.taskTitle}
 `];
   if (task.taskDescription) parts.push(`## Description
@@ -498,8 +397,30 @@ ${task.taskPlan}
   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 (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;
@@ -512,8 +433,7 @@ ${task.taskPlan}
     );
     parts.push("");
   }
-  const allGrades = [...planningResult?.turnGrades ?? [], ...buildingResult?.turnGrades ?? []];
-  const blunders = allGrades.filter((g) => g.grade === "blunder");
+  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)) {
@@ -664,16 +584,16 @@ function buildQueryOptions(systemPrompt, opts, limits, mcpServers = {}) {
     disallowedTools: ["Edit", "Write", "Bash", "NotebookEdit", "MultiEdit"]
   };
 }
-async function runGradingStep(taskId, phase, systemPrompt, userPrompt, limits, opts) {
+async function runCombinedGradingStep(taskId, userPrompt, limits, opts) {
   const harness = createHarness();
   const events = harness.executeQuery({
     prompt: userPrompt,
-    options: buildQueryOptions(systemPrompt, opts, limits)
+    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 ${phase} grading step`);
+  if (!response.text) throw new Error("No response from combined grading step");
   return {
-    result: extractGradingResult(response.text, phase),
+    result: extractCombinedGradingResult(response.text),
     costUsd: response.costUsd,
     model: response.model
   };
@@ -688,12 +608,12 @@ async function runHumanStep(taskId, userPrompt, limits, opts) {
   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) {
+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, planningResult, buildingResult, humanResult),
+    prompt: buildAnalysisPrompt(task, gradingResult, humanResult),
     options: buildQueryOptions(
       ANALYSIS_SYSTEM_PROMPT,
       opts,
@@ -711,7 +631,7 @@ async function runAnalysisStep(task, planningResult, buildingResult, humanResult
   return { result: extractAnalysisResult(response.text), costUsd: response.costUsd };
 }
 var EMPTY_STEP = { result: null, costUsd: null, model: null };
-var GRADING_LIMITS = { maxTurns: 8, maxBudgetUsd: 1 };
+var GRADING_LIMITS = { maxTurns: 24, maxBudgetUsd: 3 };
 async function executeStepSafely(stepLabel, requestId, taskId, fn) {
   try {
     const step = await fn();
@@ -725,47 +645,22 @@ async function executeStepSafely(stepLabel, requestId, taskId, fn) {
     return EMPTY_STEP;
   }
 }
-async function executePlanningStep(taskPayload, planningTrace, opts) {
-  if (planningTrace.length === 0) 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/4: Auditing planning..."
+    "Step 1/3: Auditing full workflow..."
   );
   return await executeStepSafely(
-    "Planning audit",
+    "Combined grading audit",
     opts.requestId,
     taskPayload.taskId,
-    () => runGradingStep(
+    () => runCombinedGradingStep(
       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),
+      buildCombinedGradingPrompt(taskPayload),
       GRADING_LIMITS,
       opts
     )
@@ -778,7 +673,7 @@ async function executeHumanStep(taskPayload, opts) {
     opts.requestId,
     taskPayload.taskId,
     "status",
-    "Step 3/4: Auditing human contributions..."
+    "Step 2/3: Auditing human contributions..."
   );
   return await executeStepSafely(
     "Human audit",
@@ -792,40 +687,26 @@ async function executeHumanStep(taskPayload, opts) {
     )
   );
 }
-async function executeAnalysisStep(taskPayload, planning, building, human, projectId, suggestionIds, opts) {
+async function executeAnalysisStep(taskPayload, grading, human, projectId, suggestionIds, opts) {
   reportProgress(
     opts.connection,
     opts.requestId,
     taskPayload.taskId,
     "status",
-    "Step 4/4: Generating analysis & suggestions..."
+    "Step 3/3: Generating analysis & suggestions..."
   );
   return await executeStepSafely(
     "Analysis",
     opts.requestId,
     taskPayload.taskId,
-    () => runAnalysisStep(
-      taskPayload,
-      planning.result,
-      building.result,
-      human.result,
-      projectId,
-      suggestionIds,
-      opts
-    )
+    () => runAnalysisStep(taskPayload, grading.result, human.result, projectId, suggestionIds, opts)
   );
 }
-async function reportAuditResult(connection, requestId, taskPayload, steps, planningTraceLength, suggestionIds) {
+async function reportAuditResult(connection, requestId, taskPayload, steps, suggestionIds) {
   let totalCostUsd = null;
-  for (const step of [steps.planning, steps.building, steps.human, steps.analysis])
+  for (const step of [steps.grading, 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
-  );
+  const merged = mergeStepResults(steps.grading.result, steps.human.result, steps.analysis.result);
   await connection.call("reportTaskAuditResult", {
     projectId: connection.projectId,
     requestId,
@@ -839,24 +720,21 @@ async function reportAuditResult(connection, requestId, taskPayload, steps, plan
     ...computeGradeCounts(merged.turnGrades),
     suggestionIds,
     auditCostUsd: totalCostUsd,
-    model: steps.planning.model ?? steps.building.model ?? null
+    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 { 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 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,
-    planning,
-    building,
+    grading,
     human,
     projectId,
     suggestionIds,
@@ -866,8 +744,7 @@ async function auditSingleTask(taskPayload, request, connection, projectDir, mod
     connection,
     requestId,
     taskPayload,
-    { planning, building, human, analysis },
-    planningTrace.length,
+    { grading, human, analysis },
     suggestionIds
   );
   logger.info("Task audit complete", {
@@ -903,4 +780,4 @@ async function handleTaskAudit(request, connection, projectDir) {
 export {
   handleTaskAudit
 };
-//# sourceMappingURL=task-audit-handler-Z3TBS4EN.js.map
+//# sourceMappingURL=task-audit-handler-6XWYK6KZ.js.map