feat(review): --waive for resumed runs

Add --waive path/a.go,path/b.go (requires --resume): waived diffs are not
dispatched, are recorded as review_item_waived, and count toward coverage so a
waive can flip partial -> complete. A later resume treats a waived item as
covered (indexed like a completed item, empty comments).

No fingerprint-addressed or config-file waives — paths only (ponytail note).
Tests: waive flips partial->complete, without waive stays partial, --waive
without --resume errors.

Author: chethanuk

cmd/opencodereview/flags.go

@@ -102,6 +102,7 @@ type reviewOptions struct {
 	to             string
 	commit         string
 	resume         string
+	waive          string // --waive: comma-separated paths to skip (requires --resume)
 	excludes       string // --exclude: comma-separated gitignore-style patterns
 	outputFormat   string
 	audience       string // --audience: "human" (default) or "agent"
@@ -128,6 +129,7 @@ func parseReviewFlags(args []string) (reviewOptions, error) {
 	a.StringVar(&opts.to, "to", "", "target ref to end diff at (e.g., 'feature-branch')")
 	a.StringVarP(&opts.commit, "commit", "c", "", "single commit hash or tag to review (vs its parent)")
 	a.StringVar(&opts.resume, "resume", "", "resume from a previous review session id")
+	a.StringVar(&opts.waive, "waive", "", "comma-separated paths to waive (skip but count as covered); requires --resume")
 	a.StringVar(&opts.excludes, "exclude", "", "comma-separated gitignore-style patterns to exclude; merged with rule.json excludes")
 	a.StringVarP(&opts.outputFormat, "format", "f", "text", "output format: text or json")
 	a.IntVar(&opts.concurrency, "concurrency", 8, "max concurrent file reviews")
@@ -169,6 +171,13 @@ func parseReviewFlags(args []string) (reviewOptions, error) {
 	if opts.preview && opts.resume != "" {
 		return opts, fmt.Errorf("--preview and --resume cannot be used together")
 	}
+	// Waiving only makes sense on a resumed run: it deliberately leaves diffs
+	// unreviewed while still satisfying the coverage contract. There is no
+	// fingerprint-addressed or config-file waive — paths only, and only with
+	// --resume. (ponytail: path-scoped waives cover the operator use case.)
+	if opts.waive != "" && opts.resume == "" {
+		return opts, fmt.Errorf("--waive requires --resume")
+	}
 
 	switch opts.audience {
 	case "human", "agent":
@@ -246,7 +255,8 @@ Flags:
   --rule string                 path to JSON file with system review rules
   --timeout int                 concurrent task timeout in minutes (default 10)
   --to string                   target ref to end diff at (e.g., 'feature-branch')
-  --tools string                path to JSON tools config file (default: embedded)`)
+  --tools string                path to JSON tools config file (default: embedded)
+  --waive string                comma-separated paths to waive (skip but count as covered); requires --resume`)
 }
 
 // --- config subcommand ---

cmd/opencodereview/flags_test.go

@@ -53,6 +53,19 @@ func TestParseReviewFlags_PreviewWithResume(t *testing.T) {
 	}
 }
 
+func TestParseReviewFlags_WaiveRequiresResume(t *testing.T) {
+	if _, err := parseReviewFlags([]string{"--from", "main", "--to", "feature", "--waive", "a.go"}); err == nil {
+		t.Fatal("expected error for --waive without --resume")
+	}
+	opts, err := parseReviewFlags([]string{"--from", "main", "--to", "feature", "--resume", "s1", "--waive", "a.go,b.go"})
+	if err != nil {
+		t.Fatalf("--waive with --resume should be valid: %v", err)
+	}
+	if opts.waive != "a.go,b.go" {
+		t.Errorf("waive = %q", opts.waive)
+	}
+}
+
 func TestParseReviewFlags_InvalidAudience(t *testing.T) {
 	_, err := parseReviewFlags([]string{"--audience", "robot"})
 	if err == nil {

cmd/opencodereview/review_cmd.go

@@ -127,6 +127,7 @@ func runReview(args []string) error {
 		GitRunner:             cc.GitRunner,
 		Resume:                resumeState,
 		RunMeta:               runMeta,
+		WaivePaths:            splitPaths(opts.waive),
 	})
 
 	// Silence progress output during execution; restored before the trace

internal/agent/agent.go

@@ -125,6 +125,11 @@ type Args struct {
 	// is folded into the run manifest at Finalize. Ignored when Session is
 	// supplied pre-built by the caller.
 	RunMeta session.RunMeta
+
+	// WaivePaths lists repo-relative paths to waive on a resumed run: they are
+	// not dispatched, are recorded as review_item_waived, and count toward
+	// coverage. Only honored alongside Resume (the CLI enforces --resume).
+	WaivePaths []string
 }
 
 // Agent orchestrates the AI-powered code review. LLM tool-use loop / memory
@@ -481,6 +486,11 @@ func (a *Agent) applyResume(diffs []model.Diff) []model.Diff {
 		return diffs
 	}
 
+	waived := make(map[string]struct{}, len(a.args.WaivePaths))
+	for _, p := range a.args.WaivePaths {
+		waived[p] = struct{}{}
+	}
+
 	mode := a.reviewMode()
 	toDispatch := make([]model.Diff, 0, len(diffs))
 	var reused int64
@@ -490,6 +500,12 @@ func (a *Agent) applyResume(diffs []model.Diff) []model.Diff {
 			continue
 		}
 		fingerprint := reviewItemFingerprint(mode, d)
+		// An explicit waive wins over both reuse and re-review: the operator
+		// chose to skip this diff while still satisfying coverage.
+		if _, ok := waived[effectivePath(d)]; ok {
+			a.session.RecordReviewItemWaived(effectivePath(d), d.OldPath, d.NewPath, fingerprint)
+			continue
+		}
 		item, ok := resume.Item(fingerprint)
 		if !ok {
 			toDispatch = append(toDispatch, d)

internal/agent/manifest_test.go

@@ -184,6 +184,59 @@ func TestRunManifest_Scenarios(t *testing.T) {
 	}
 }
 
+// TestWaiveCoverage verifies a waived diff is not dispatched, is recorded as
+// covered, and flips an otherwise-partial run to complete.
+func TestWaiveCoverage(t *testing.T) {
+	build := func(waive []string) *session.RunManifest {
+		sess := session.New(t.TempDir(), "main", "test", session.SessionOptions{ReviewMode: session.ReviewModeRange})
+		a := New(Args{
+			LLMClient: routeClient{},
+			Model:     "test",
+			Session:   sess,
+			Tools:     tool.NewRegistry(),
+			Template: template.Template{
+				MaxTokens:           100000,
+				MaxToolRequestTimes: 5,
+				MainTask:            template.LlmConversation{Messages: []template.ChatMessage{{Role: "user", Content: "{{diff}}"}}},
+			},
+			MainToolDefs: []llm.ToolDef{{Type: "function", Function: llm.FunctionDef{Name: "task_done"}}},
+			// Resume must be non-nil for applyResume (and thus waive) to run.
+			Resume:     &session.ResumeState{SessionID: "prev", Items: map[string]session.ResumeItem{}},
+			WaivePaths: waive,
+		})
+		a.currentDate = "d"
+		a.diffs = []model.Diff{
+			{NewPath: "ok.go", OldPath: "ok.go", Diff: "+ok", Insertions: 1},
+			{NewPath: "flaky.go", OldPath: "flaky.go", Diff: "+DO_FAIL", Insertions: 1},
+		}
+		_, _ = a.dispatchSubtasks(context.Background())
+		sess.Finalize()
+		return sess.Manifest()
+	}
+
+	// No waive: the failing diff leaves the run partial.
+	noWaive := build(nil)
+	if noWaive.State != session.StatePartial {
+		t.Errorf("without waive: state = %q, want partial (files=%+v)", noWaive.State, noWaive.Files)
+	}
+
+	// Waiving the failing diff flips the run to complete and records it as
+	// waived rather than dispatched/failed.
+	waived := build([]string{"flaky.go"})
+	if waived.State != session.StateComplete {
+		t.Errorf("with waive: state = %q, want complete (files=%+v)", waived.State, waived.Files)
+	}
+	if len(waived.Files.Waived) != 1 || waived.Files.Waived[0] != "flaky.go" {
+		t.Errorf("waived set = %v, want [flaky.go]", waived.Files.Waived)
+	}
+	if len(waived.Files.Failed) != 0 {
+		t.Errorf("waived diff must not be recorded as failed: %v", waived.Files.Failed)
+	}
+	if len(waived.Files.Completed) != 1 || waived.Files.Completed[0] != "ok.go" {
+		t.Errorf("completed set = %v, want [ok.go]", waived.Files.Completed)
+	}
+}
+
 // TestArtifactChecksumStableAndOrderIndependent verifies the artifact hash is
 // deterministic regardless of diff ordering (fingerprints are sorted).
 func TestArtifactChecksumStableAndOrderIndependent(t *testing.T) {

internal/session/resume.go

@@ -111,7 +111,9 @@ func (s *ResumeState) applyResumeLine(line []byte) error {
 	switch rec.Type {
 	case "session_start":
 		s.applySessionStart(rec)
-	case "review_item_done", "review_item_reused":
+	case "review_item_done", "review_item_reused", "review_item_waived":
+		// A waived item counts as covered for later resumes: index it like a
+		// completed item (empty comments) so a subsequent resume skips it.
 		if rec.Fingerprint == "" {
 			return nil
 		}