Add durable discussion summarization before dossier assembly

[rianjs]

Parent: #366

Problem statement

Raw top-level comments and inline threads can be noisy, stale, duplicated, or settled. Stuffing the raw discussion into downstream prompts is another form of context stuffing and can poison reviewer judgment.

Proposed change

Add a durable LLM task that runs after raw PR discussion fetch and gate/override checks, but before final dossier assembly. It should summarize and normalize top-level comments and inline threads into structured artifacts that the dossier builder can consume.

The summary should represent:

• Top-level comments that affect review judgment.
• Inline threads mapped to file/line anchors.
• Settled threads as concise decisions, for example Settled: Decided <decision>.
• Unresolved human disagreement with enough detail to preserve the open question.
• Agent/bot threads aggressively summarized when settled.

Empirical success criteria

• First run emits an existing structured progress line like op="run_llm_task" task_id="dossier-discussion-summary" phase="dossier".
• Re-running without discussion changes emits op="load_llm_task" for the same task.
• Adding or changing a relevant comment/thread changes the discussion payload digest and reruns this task plus dependent downstream tasks.
• Generated summary artifacts preserve file/line anchors for inline threads.
• Settled and unresolved thread examples are distinguishable in the generated output.

Additional context

The logging breadcrumbs are only observability for this task. The core deliverable is reusable, anchored discussion context for dossier assembly.

[rianjs]

Issue 369 Plan

Issue: #369 Add durable discussion summarization before dossier assembly

Intent

Insert a durable, reusable discussion-summary task between raw PR discussion
fetch and reviewer-facing dossier assembly. The raw provider payloads should
still be persisted, but the final dossier should consume normalized summary
artifacts rather than projecting raw comments and threads directly.

This slice needs to fit the code that exists after #368:

• raw discussion is fetched in prepareSelectionContext
• raw and final dossier artifacts are currently written immediately from that
  prepared context
• durable LLM task reuse already exists in internal/pipeline

The plan should preserve that shape, but split dossier work into:

1. raw discussion capture
2. durable discussion summarization
3. final dossier assembly from the normalized summary

Design Decisions

1. Treat raw discussion artifacts as the source input for summarization.
   • Reuse dossier/raw/top-level-comments.json and
     dossier/raw/inline-threads.json.
   • Do not summarize directly from in-memory provider structs if we can avoid
     it; the persisted raw artifacts make the cache/debug story clearer.
2. Give the summary task a dedicated LLM task identity:
   • task_id = "dossier-discussion-summary"
   • phase = "dossier"
3. Make summary outputs structured first, readable second.
   • Primary artifact: normalized JSON for downstream assembly
   • Secondary artifact: markdown snapshot for human inspection/debugging
4. Pinned reviews should not summarize current discussion.
   • Keep the explicit omission note path from Create raw PR context and dossier artifact assembly #368.
5. SelectionOnly should also be able to reuse summary artifacts in a
   caller-owned artifact root.
   • But normal cr review should keep the existing durable run/session model.
   • Optional session persistence should apply only to SelectionOnly /
     caller-owned artifact roots with no allocated run.

Implementation

1. Split the current prepareSelectionContext dossier path into two stages:
   • prepareSelectionContext keeps raw fetch plus raw dossier artifact write
   • a new post-run dossier-preparation step handles discussion summarization
     and final dossier assembly
     This sequencing is required because normal DryRun/Live reviews allocate a
     run only after prepareSelectionContext, and the durable summary task should
     run with that real run ID.
2. Refactor dossier writing into three helpers under internal/pipeline:
   • writeRawDossierArtifacts(...)
   • summarizeDiscussionArtifacts(...)
   • writeFinalDossierArtifacts(...)
     Keep writeDossierArtifacts(...) as the orchestration layer if that keeps
     call sites narrow.
3. Introduce normalized summary types for dossier discussion, separate from raw
   provider projections. They should represent:
   • top-level comments worth carrying forward
   • inline thread summaries with path/line/side/anchor fields preserved
   • settled thread decisions in concise form
   • unresolved disagreement with enough detail to preserve the open question
   • omission note for pinned reviews
4. Build a structured summarizer prompt from the raw dossier artifacts.
   • Input should explicitly distinguish top-level comments vs inline threads.
   • Thread input should carry file/line anchors and resolved state.
   • Prompt should instruct the model to compress settled bot/agent discussion
     aggressively and preserve unresolved human disagreement.
5. Add an explicit input-budgeting layer before the summarizer task.
   • Build a deterministic discussion-input projection with bounded counts and
     excerpt sizes per top-level comment/thread/comment body.
   • Preserve path/line anchors and omitted-count signals when truncation
     occurs.
   • If the bounded projection still exceeds the prompt budget, fail clearly
     with a dossier-summary budget error rather than stuffing the full raw
     payload into the summarizer prompt.
6. Carry forward the reviewer-facing exclusion rules explicitly in both prompt
   construction and final rendering.
   • Approval state and other review-event state must not appear in the summary
     artifact consumed by the final dossier.
   • CI/build chatter, mergeability/process state, session IDs, retry/cache
     bookkeeping, and stale bot/process noise must stay out of the reviewer-
     facing summary/rendered dossier.
   • Add validation-oriented tests that dossier/final/discussion.md cannot
     reintroduce these fields.
7. Run the summarizer through existing durable task machinery.
   • Use runStructuredTask when a review run exists.
   • Add a tightly scoped no-run durable-task mode only for SelectionOnly /
     caller-owned artifact roots, so cached task output can be written and
     loaded without forcing a ledger session insert/load.
8. Persist summary artifacts under dossier/summary/.
   • Write normalized JSON that final dossier assembly consumes.
   • Write a markdown rendering for inspection.
   • Include enough provenance in the summary artifact to tie it to the current
     raw discussion content, so stale caller-owned artifacts cannot be reused
     silently.
9. Change final dossier discussion assembly to consume only the normalized
   summary artifact for non-pinned reviews.
   • Remove the raw-comment fallback from the final reviewer-facing discussion
     path.
   • Keep raw artifacts available for debugging and future phases.
10. Make the summary task fingerprint and reuse boundary reflect discussion
    changes.

• Fingerprint must change when raw top-level comments or inline threads
  change.
• Downstream dossier artifacts should rebuild when the summary output
  changes.

11. Update docs/llm-task-artifacts.md in this ticket.
    • Document the new dossier task identity and phase.
    • Document the no-run cache/load semantics for SelectionOnly, and whether
      the task metadata schema changes or why it does not.
12. Keep orchestrator selection scope unchanged in this issue.

• #371 owns converting selection to dossier/workbench mode.
• This issue should prepare durable summary artifacts now, not broaden
  prompt routing scope early.

Verification

1. Unit/integration coverage in internal/pipeline:
   • first run writes dossier/summary/* artifacts and summary task metadata
   • second run with unchanged raw discussion loads the cached
     dossier-discussion-summary task instead of rerunning it
   • changing an issue comment or inline thread invalidates the cached summary
   • pinned review skips the summarizer and keeps the omission note behavior
   • final reviewer-facing dossier/final/discussion.md is assembled from the
     normalized summary artifact, not raw fallback text
   • inline anchors survive into summary outputs
   • settled vs unresolved examples remain distinguishable in structured output
   • over-budget raw discussion inputs are bounded deterministically or fail
     with the expected dossier-summary budget error
   • final reviewer-facing discussion excludes approval state, CI/process
     chatter, mergeability, and session/cache bookkeeping fields
2. Durable-task coverage:
   • normal cr review runs the dossier summary task after run allocation and
     persists the expected ledger session/task metadata
   • cached summary artifacts can be reused when SelectionOnly runs with a
     caller-owned artifact root and no persisted run ID
   • no ledger/session lookup is required to read a cached task with empty
     runID
3. Docs check:
   • docs/llm-task-artifacts.md describes the dossier summary task and the
     scoped no-run reuse semantics
4. Local gates:
   • rtk make lint
   • rtk make test
5. Empirical check outside unit tests:
   • run the same review twice against a stable PR fixture or real PR
   • observe stderr once with op="run_llm_task" task_id="dossier-discussion-summary" phase="dossier"
   • rerun unchanged and observe op="load_llm_task" for the same task
   • mutate the relevant discussion input, rerun, and observe the summary task
     plus dependent dossier assembly refresh

Open Question Resolved in This Plan

SelectionOnly currently has no run ID, but the issue’s reuse goal is still
worth preserving there. The least invasive approach is:

• normal cr review: run the summary task only after run allocation, with the
  existing durable run/session model intact
• SelectionOnly: allow cached summary reuse from artifact metadata plus
  validated output files without requiring a ledger-backed session row

That keeps the normal durable-task model strong while still making caller-owned
artifact roots useful.