resume session %q selected no input, so it has nothing to re

Error message

resume session %q selected no input, so it has nothing to resume; %s

What it means

validateInputIdentity rejects resuming a session whose manifest selected no input (empty Coverage.Selected). Without selected input, parent and child would hash to the same canonical empty digest, pass every comparison, and produce a resumed run that reuses nothing and dispatches nothing — so it is rejected as meaningless.

Source

Thrown at internal/session/resume_identity.go:104

	case m == nil && !s.Closed:
		// Distinguishing all of these from "manifest present, zero completed
		// items" is the whole point: that one is resumable, none of these are.
		return fmt.Errorf("resume session %q was interrupted before it closed, so it never recorded a run manifest and its input identity cannot be verified; %s", s.SessionID, resumeHint)
	case m == nil:
		// It closed cleanly, so blaming an interruption would send the user
		// looking for a crash that never happened. A session_end with no manifest
		// is a session older than run manifests, or a run that failed before
		// freezing one.
		return fmt.Errorf("resume session %q closed without a run manifest, so its input identity cannot be verified — it either predates run manifests or failed before recording one; %s", s.SessionID, resumeHint)
	case m.SchemaVersion != ManifestSchemaVersion:
		return fmt.Errorf("resume session %q carries manifest schema %q, but this build can only verify %q; %s", s.SessionID, m.SchemaVersion, ManifestSchemaVersion, resumeHint)
	case m.Operation != OperationReview:
		return fmt.Errorf("resume session %q recorded operation %q, not %q; %s", s.SessionID, m.Operation, OperationReview, resumeHint)
	case len(m.Coverage.Selected) == 0:
		// Without this, an empty parent and an empty child would both hash to the
		// canonical empty digest, pass every comparison, and produce a run that
		// reuses nothing and dispatches nothing.
		return fmt.Errorf("resume session %q selected no input, so it has nothing to resume; %s", s.SessionID, resumeHint)
	}

	if m.Input.Mode != id.Mode {
		// Mode feeds item_id derivation, so parent and child items cannot even be
		// put side by side.
		return fmt.Errorf("resume rejected: input mode changed from %q to %q; %s", m.Input.Mode, id.Mode, resumeHint)
	}
	// Both sides empty means a repository with no remote, which is unchanged.
	if m.Repository.IdentitySHA256 != id.RepositorySHA256 {
		return fmt.Errorf("resume rejected: repository identity changed, so this is not the repository the parent run reviewed; %s", resumeHint)
	}
	if m.Input.SourceArtifactSHA256 != id.SourceArtifactSHA256 {
		return fmt.Errorf("resume rejected: the reviewed input changed since session %q — a ref may now point at a different commit, or the selected file set changed; %s", s.SessionID, resumeHint)
	}
	if m.Execution.RuleConfigSHA256 == "" {
		return fmt.Errorf("resume session %q recorded no rule identity, so it cannot be verified against the current rules; %s", s.SessionID, resumeHint)
	}
	if m.Execution.RuleConfigSHA256 != id.RuleConfigSHA256 {

View on GitHub (pinned to 5cf97d0d15)

Solutions

Start a new review with actual input instead of resuming an empty run
Check that the target branch/PR/refs actually contain changes and re-run the review
Verify you are resuming the intended (non-empty) session ID

Defensive patterns

Strategy: validation

Validate before calling

// Skip resume for sessions that selected no input
if sess.Manifest != nil && len(sess.Manifest.Coverage.Selected) == 0 {
    return fmt.Errorf("session %s selected no input; start a new review", sess.SessionID)
}

Type guard

func hasSelectableInput(m *session.Manifest) bool {
    return m != nil && len(m.Coverage.Selected) > 0
}

Try / catch

if err := ValidateResume(s, req); err != nil {
    if strings.Contains(err.Error(), "selected no input") {
        return startNewReview(req)
    }
    return err
}

Prevention

Verify the diff/PR actually has changes before starting a review
Check the mode/ref resolves to a non-empty file set before resuming
Empty reviews are dead ends — treat them as fresh-run candidates only

When it happens

Trigger: ValidateResume where len(m.Coverage.Selected) == 0 — the parent review ran against an empty change set / empty file selection and recorded nothing to resume from.

Common situations: Resuming a review of a PR or diff that had no changed files; a run where the mode/ref resolved to zero files; resuming the wrong (empty) session.

Related errors

AI-assisted analysis of alibaba/open-code-review@5cf97d0d15 (2026-09-02). Data as JSON: /api/errors/18b4312e14f779fb. Report an issue: GitHub.