iterate-plugin 2.7.3 → 2.8.1

package/src/tools/review.ts

@@ -1,9 +1,22 @@
 import { defineTool } from '@deepseek-ai/dsh-tools'
 import type { JsonValue } from '@deepseek-ai/dsh-session'
 import { loadEffectiveConfig, resolveProjectRoot } from '../config-loader.ts'
-import { buildReviewPlan, buildReviewReport } from '../review.ts'
+import {
+  buildReviewPlan,
+  buildReviewReport,
+  sanitizeRounds,
+  validateRoundsSchema,
+} from '../review.ts'
 import { buildFinalReviewReport, metaReviewReport } from '../meta-review.ts'
+import { evidenceToPlain, verifyFindings } from '../evidence.ts'
+import {
+  collectScopeFiles,
+  computeCoverage,
+  coverageToDict,
+} from '../review-scope.ts'
+import { resolveChangedFiles } from '../git-scope.ts'
 import type { KnownIntentional, ReviewFinding, ReviewReport, ReviewRound } from '../types.ts'
+import type { CoverageResult } from '../review-scope.ts'
 
 /** Default round cap when neither the arg nor config provides one. */
 const DEFAULT_MAX_REVIEW_ROUNDS = 3
@@ -94,6 +107,21 @@ export function registerReviewTool(ctx: { tools: { register: (def: ReturnType<ty
             found: { type: 'boolean' },
             plan: { type: 'json' },
             report: { type: 'json' },
+            schemaValidation: {
+              type: 'json',
+              description:
+                'For `aggregate`: per-round schema validation results (round, valid, issues). ' +
+                'Present only when reviewer.output_schema_validation is enabled; the workflow ' +
+                'retries rounds with valid=false (≤2 times) before forwarding findings.',
+            },
+            evidence: { type: 'json' },
+            coverage: {
+              type: 'json',
+              description:
+                'For `meta-review`: prompt-informative scope coverage result ' +
+                '(assigned vs self-reported reads). Present only when ' +
+                'reviewer.coverage_validation is enabled and readFiles were supplied.',
+            },
             finalReport: { type: 'json' },
             error: { type: 'string' },
           },
@@ -118,7 +146,23 @@ export function registerReviewTool(ctx: { tools: { register: (def: ReturnType<ty
           const maxReviewRounds = args.maxReviewRounds ?? config.max_rounds ?? DEFAULT_MAX_REVIEW_ROUNDS
           const knownIntentional = (config.personalization as { known_intentional?: KnownIntentional[] } | undefined)
             ?.known_intentional
-          const plan = buildReviewPlan({ config, mode, maxReviewRounds, knownIntentional })
+          // changed-only scope: resolve the changed-file set against
+          // git.target_branch before building the plan so reviewers get the
+          // concrete file list (and the plan auto-falls back to full when there
+          // are no changes). git failures degrade to a full-scope plan.
+          let changedFiles: string[] | undefined
+          if (config.review?.scope === 'changed-only') {
+            const gitScope = await resolveChangedFiles(projectRoot, config.git?.target_branch ?? 'main')
+            changedFiles = gitScope.changedFiles
+          }
+          // Full-codebase review: pre-collect the source inventory so
+          // buildReviewPlan can batch it into per-chunk reviewer tasks
+          // (coverage enforcement).
+          let scopeFiles: string[] | undefined
+          if (config.review?.scope === 'full') {
+            scopeFiles = collectScopeFiles(projectRoot, { scope: 'full' })
+          }
+          const plan = buildReviewPlan({ config, mode, maxReviewRounds, knownIntentional, changedFiles, scopeFiles })
           return { operation: 'plan', mode, found: true, plan: plan as unknown as JsonValue }
         }
 
@@ -143,16 +187,34 @@ export function registerReviewTool(ctx: { tools: { register: (def: ReturnType<ty
           const maxReviewRounds = args.maxReviewRounds ?? config.max_rounds ?? DEFAULT_MAX_REVIEW_ROUNDS
           const goal = args.goal ?? config.goal ?? ''
           const dimensions = config.dimensions ?? []
+
+          // Output schema validation gate (reviewer.output_schema_validation,
+          // default true): validate every round's findings against the findings
+          // schema, then drop schema-invalid entries before the deterministic
+          // core so malformed reviewer output can never crash dedupe/sort or
+          // leak into fixes. The `schemaValidation` array is surfaced so the
+          // workflow can retry failing rounds (≤2 times) with a strict-JSON
+          // nudge. When disabled, non-object entries are still dropped for
+          // crash-safety.
+          const schemaEnabled = config.reviewer?.output_schema_validation !== false
+          const schemaValidation = schemaEnabled ? validateRoundsSchema(rounds) : null
+          const cleanRounds = sanitizeRounds(rounds, schemaValidation)
+
           const report = buildReviewReport({
             mode,
             goal,
             dimensions,
             maxReviewRounds,
-            rounds,
+            rounds: cleanRounds,
             knownIntentional: args.knownIntentional as KnownIntentional[] | undefined,
             fixedCount: typeof args.fixedCount === 'number' ? args.fixedCount : undefined,
           })
-          return { operation: 'aggregate', mode, report: report as unknown as JsonValue }
+          return {
+            operation: 'aggregate',
+            mode,
+            report: report as unknown as JsonValue,
+            schemaValidation: schemaValidation as unknown as JsonValue | undefined,
+          }
         }
 
         if (args.operation === 'meta-review') {
@@ -165,12 +227,36 @@ export function registerReviewTool(ctx: { tools: { register: (def: ReturnType<ty
             }
           }
           const audit = metaReviewReport(source)
-          const finalReport = buildFinalReviewReport(source)
+          // Hard code-evidence gate (default on): every finding's file/line is
+          // validated against real files on disk before folding into the final
+          // verdict. Disable via config `reviewer.evidence_validation: false`.
+          const evidenceEnabled = config.reviewer?.evidence_validation !== false
+          const findings: ReviewFinding[] = Array.isArray(source.findings) ? source.findings : []
+          const evidence = evidenceEnabled ? verifyFindings(projectRoot, findings) : null
+          // Prompt-informative coverage: compare the reviewer's self-reported
+          // reads against the assigned scope inventory (never flips the
+          // verdict). Disable via config `reviewer.coverage_validation: false`.
+          const coverageEnabled = config.reviewer?.coverage_validation !== false
+          let coverage: CoverageResult | null = null
+          if (coverageEnabled) {
+            const assigned = collectScopeFiles(projectRoot, {
+              scope: config.review?.scope === 'changed-only' ? 'changed-only' : 'full',
+            })
+            const readFiles = Array.isArray((source as unknown as { readFiles?: unknown }).readFiles)
+              ? ((source as unknown as { readFiles?: unknown }).readFiles as string[])
+              : null
+            if (readFiles && readFiles.length > 0) {
+              coverage = computeCoverage(assigned, readFiles)
+            }
+          }
+          const finalReport = buildFinalReviewReport(source, { evidence, coverage })
           return {
             operation: 'meta-review',
             mode,
             found: true,
             report: audit as unknown as JsonValue,
+            evidence: evidence ? (evidenceToPlain(evidence) as unknown as JsonValue) : null,
+            coverage: coverage ? (coverageToDict(coverage) as unknown as JsonValue) : null,
             finalReport: finalReport as unknown as JsonValue,
           }
         }

package/src/types.ts

@@ -16,7 +16,12 @@ export interface IterateConfig {
     command_whitelist: string[]
     commands: Record<string, string[]>
   }
-  reviewer: { output_schema_validation: boolean }
+  reviewer: {
+    output_schema_validation: boolean
+    evidence_validation: boolean
+    coverage_validation: boolean
+    scope_chunk_size: number
+  }
   onboarding?: Record<string, unknown>
   personalization?: Record<string, unknown>
 }