diff --git a/docs/code-navigation.md b/docs/code-navigation.md
index cb7d6122..1cd834ac 100644
--- a/docs/code-navigation.md
+++ b/docs/code-navigation.md
@@ -21,10 +21,10 @@ Start with the issue's terms in `GLOSSARY.md`, then use this index to find their
 | CI-red Ticket, Flaky-test Ticket | `src/github/base_ci.rs` — latest push attempts, failed-jobs re-run, evidence and report deduplication; `src/pickup.rs` — CI reservation and reporting; `src/implement.rs` — recorded flaky evidence bypasses bug diagnosis; `src/labels.rs` — `FLAKY_TEST` | `tests/pickup_run/base_ci.rs`, `tests/bug_run.rs` |
 | Inherited failure, check-state reading, Base fix | `src/ci.rs` — `reading` of each `Conclusion` the GitHub adapter (`src/github.rs`, `checks_on`) reports; `src/base_fix.rs` | Inline tests; `src/github/execution_tests.rs`; `tests/ci.rs`, `tests/base_fix.rs` |
 | Run notification | `src/notification.rs` — `RunNotification`; `src/email.rs` | `tests/run_notification.rs`, `tests/email_test.rs` |
-| Report, Triage run | `src/triage.rs` — `Report`, `parse_recommendation`, `check_publication` (the GitHub checks both modes make), `publish` (filing, cross-links, closing `wontfix`, comments), questionnaires and session; `src/args.rs` — `TriageArgs`; `src/config.rs` — `triage.allow_ready_for_agent`, `triage.read_machine`, `triage_reads_machine`; `src/sandbox/triage.rs` — the `--read-machine` bwrap launch (read-only host, writable worktree, private Harness home, startup probe) and its host-socket seccomp filter; `src/sandbox.rs` — `Launch::pass_seccomp`; `skills/thirdshift-triage/`, `skills/thirdshift-to-questionnaire/`; `src/worktree.rs` — `ReviewWorktree::for_triage` | `tests/triage_run.rs`, `tests/issue_1711_retained_home.rs`; `src/sandbox/triage.rs` inline tests (the launch and seccomp filter) |
-| Existing-issue Triage run | `src/triage/existing.rs` — trust gate, single-issue recommendation, reservation and Claim lifetime, in-place publication; `src/triage/images.rs` — trusted image extraction, bounded host downloads and local issue manifest; `src/prompt.rs` — `triage_issue`; `src/args.rs` — `TriageArgs` | `tests/triage_issue.rs`; `src/triage/images.rs` inline tests |
+| Report, Triage run | `src/triage.rs` — `Report`, `check_comment_targets` (the GitHub checks both modes make), `publish` (filing, cross-links, closing `wontfix`, comments) and session; `src/triage/recommendation.rs` — `Recommendation::interpret` for the initial and corrected session output: category fallback and repository spelling, factory labels, state fallback, confirmation blocks, questionnaires, existing-issue rules, readiness permission and combined diagnostics; each proposed issue's `Filing` and each comment's target, `publishing`, recorded results, stdout JSON and the notification; `src/triage/correction.rs` — the one correction turn; `src/args.rs` — `TriageArgs`; `src/config.rs` — `triage.allow_ready_for_agent`, `triage.read_machine`, `triage_reads_machine`; `src/sandbox/triage.rs` — the `--read-machine` bwrap launch (read-only host, writable worktree, private Harness home, startup probe) and its host-socket seccomp filter; `src/sandbox.rs` — `Launch::pass_seccomp`; `skills/thirdshift-triage/`, `skills/thirdshift-to-questionnaire/`; `src/worktree.rs` — `ReviewWorktree::for_triage` | `tests/triage_run.rs`, `tests/triage_correction.rs`, `tests/issue_1711_retained_home.rs`; `src/triage/recommendation/tests.rs` (interpretation through `Recommendation::interpret`); `src/sandbox/triage.rs` inline tests (the launch and seccomp filter) |
+| Existing-issue Triage run | `src/triage/existing.rs` — trust gate, reservation and Claim lifetime, in-place publication; `src/triage/recommendation.rs` — the single-issue recommendation rules; `src/triage/images.rs` — trusted image extraction, bounded host downloads and local issue manifest; `src/prompt.rs` — `triage_issue`; `src/args.rs` — `TriageArgs` | `tests/triage_issue.rs`; `src/triage/recommendation/tests.rs` (existing-target rules); `src/triage/images.rs` inline tests |
 | Unattended Triage Pass | `src/triage.rs` — `Input::read` resolves terminal/empty stdin before startup; `src/triage/pass.rs` — Command-limit admission, Sweep and Failure limit, ordered candidate selection, reservation and recheck; `src/pickup.rs` — shared `failures` accounting; `src/logs.rs` — `Pass::Triage` | `tests/triage_pass.rs` |
-| Triage Report Base branch, private finding notifications | `src/launch.rs` — `selected_base`; `src/triage/existing.rs` — private finding metadata; `src/triage.rs` — notification and failure context; `src/run_ending.rs`, `src/notification.rs` — keep private failure details local | `tests/triage_spec_regressions.rs` |
+| Triage Report Base branch, private finding notifications | `src/launch.rs` — `selected_base`; `src/triage/existing.rs` — private finding metadata; `src/triage/recommendation.rs` — `Recommendation::notification` and `one_line` field sanitization; `src/triage.rs` — chooses the private finding notice over the recommendation notification, and failure context; `src/run_ending.rs`, `src/notification.rs` — keep private failure details local | `tests/triage_spec_regressions.rs` |
 | Harness, Model, Effort | `src/harness.rs` and `src/harness/` | `tests/harness_choice.rs`, `tests/harness.rs` |
 | Built-with line | `src/harness/built_with.rs` — retained attribution reader, formatter and marker; `src/pull_request.rs` — PR body annotation | `tests/scoring.rs`, inline Harness and pull-request tests |
 | Retained pull-request attribution, Continuation identity | `src/logs/reading/attribution.rs` — `PullRequestAttribution`: normalized PR matching, chronological latest and exact lexical record-path/Command-name selection over a captured `Snapshot`; `src/logs/reading.rs` — `run_for_pull_request` filesystem adapter; Scoring samples and Bug-origin proposal/settlement use that adapter; `src/logs/metrics/bug_origins.rs` uses the existing metrics Snapshot | `src/logs/reading/tests.rs`, `src/logs/reading/attribution_tests.rs`, `tests/scoring.rs`, `tests/bug_origins/settlement.rs`, `tests/metrics.rs` |
diff --git a/src/triage.rs b/src/triage.rs
index 1777a585..e4dcda8c 100644
--- a/src/triage.rs
+++ b/src/triage.rs
@@ -3,22 +3,23 @@
 use std::io::{IsTerminal, Read};
 
 use anyhow::{Context, Result, ensure};
-use serde::{Deserialize, Serialize};
 
 use crate::failed_run::FailedRun;
 use crate::git::Git;
 use crate::github::{GENERATED, GitHub};
 use crate::harness::Choice;
 use crate::issue::{IssueInput, IssueUrl, Repo};
-use crate::labels::{self, Label};
+use crate::labels;
 use crate::{command_limit, launch, logs, prompt, session, worktree};
 
 mod correction;
 mod existing;
 mod images;
 mod pass;
+mod recommendation;
 
 pub use pass::{Outcome, run as run_pass};
+use recommendation::{Publishing, Recommendation, is_factory_label};
 
 /// Input is resolved before Setup can consume a piped Report.
 pub enum Input {
@@ -27,6 +28,14 @@ pub enum Input {
 }
 
 impl Input {
+    /// The existing issue to triage in place, if this is not a Report.
+    fn issue(&self) -> Option<&IssueUrl> {
+        match self {
+            Self::Issue(issue) => Some(issue),
+            Self::Report(_) => None,
+        }
+    }
+
     /// No supplied work means an unattended Pass. Resolve stdin before Setup.
     pub fn read(issue: Option<IssueInput>, file: Option<&str>) -> Result<Option<Self>> {
         if let Some(issue) = issue {
@@ -93,226 +102,6 @@ impl Report {
     }
 }
 
-#[derive(Deserialize, Serialize)]
-#[serde(deny_unknown_fields)]
-struct Recommendation {
-    category: String,
-    state: String,
-    issues: Vec<ProposedIssue>,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    comments: Vec<ProposedComment>,
-    investigation: String,
-}
-
-#[derive(Deserialize, Serialize)]
-#[serde(deny_unknown_fields)]
-struct ProposedComment {
-    url: String,
-    body: String,
-}
-
-#[derive(Deserialize, Serialize)]
-#[serde(deny_unknown_fields)]
-struct ProposedIssue {
-    title: String,
-    body: String,
-    #[serde(skip_deserializing, skip_serializing_if = "Option::is_none")]
-    url: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    category: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    state: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    confirmation_blocked: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    questionnaire: Option<String>,
-    /// The state the issue is filed with before readiness permission,
-    /// resolved once by [`resolve_recommendation`].
-    #[serde(skip)]
-    triaged: Option<Label>,
-}
-
-impl Recommendation {
-    /// A readable Run notification, leaving full issue and comment bodies on stdout.
-    /// Fields stay inside their records: a line break in session text must not
-    /// open another `Issue:` line, and terminal controls must not be written out.
-    fn notification(&self) -> String {
-        let mut notification = format!(
-            "Investigation:\n{}\n\nRecommendation: {} ({})\n",
-            investigation_text(&self.investigation),
-            one_line(&self.category),
-            one_line(&self.state)
-        );
-        if !self.issues.is_empty() {
-            notification.push_str("\nIssues:\n");
-            for issue in &self.issues {
-                notification.push_str(&format!(
-                    "- {} ({}, {})\n",
-                    one_line(&issue.title),
-                    one_line(issue.category.as_deref().unwrap_or(&self.category)),
-                    one_line(issue.state.as_deref().unwrap_or(&self.state))
-                ));
-                if let Some(url) = &issue.url {
-                    notification.push_str(&format!("Issue: {}\n", one_line(url)));
-                }
-            }
-        }
-        if !self.comments.is_empty() {
-            notification.push_str("\nComment targets:\n");
-            for comment in &self.comments {
-                notification.push_str(&format!("- {}\n", one_line(&comment.url)));
-            }
-        }
-        for issue in &self.issues {
-            if let Some(questionnaire) = &issue.questionnaire {
-                notification.push_str(&format!("\nQuestionnaire: {}\n", one_line(&issue.title)));
-                if let Some(url) = &issue.url {
-                    notification.push_str(&format!("Issue: {}\n", one_line(url)));
-                }
-                notification.push_str(&format!("\n{questionnaire}\n"));
-            }
-        }
-        notification
-    }
-}
-
-/// One notification field. Line breaks and terminal controls would otherwise
-/// open another record, such as a forged `Issue:` line.
-fn one_line(text: &str) -> String {
-    let mut collapsed = String::with_capacity(text.len());
-    let mut pending_space = false;
-    for ch in text.chars() {
-        if ch == '\u{2028}' || ch == '\u{2029}' || ch.is_control() {
-            pending_space = !collapsed.is_empty();
-            continue;
-        }
-        if pending_space {
-            collapsed.push(' ');
-            pending_space = false;
-        }
-        collapsed.push(ch);
-    }
-    collapsed
-}
-
-/// The investigation, one indented line per row, so none of its text stands
-/// as its own notification record.
-fn investigation_text(text: &str) -> String {
-    text.split('\n')
-        .map(|line| format!("  {}", one_line(line)))
-        .collect::<Vec<_>>()
-        .join("\n")
-}
-
-const INCOMPLETE: &str = "the Triage recommendation needs a category, triage state, investigation and complete proposed issues or comments";
-
-/// Read the session's final recommendation line. The session's prose stays
-/// out of the machine-readable stdout contract.
-fn read_recommendation(message: Option<&str>) -> Result<Recommendation> {
-    let json = message
-        .and_then(|message| {
-            message
-                .lines()
-                .rev()
-                .find_map(|line| line.strip_prefix("Triage recommendation: "))
-        })
-        .context("the Triage session ended without its final Triage recommendation: JSON line")?;
-    serde_json::from_str(json).context("the Triage recommendation is not valid recommendation JSON")
-}
-
-/// Check a read recommendation is complete and resolve each proposed issue's state.
-fn resolve_recommendation(recommendation: &mut Recommendation) -> Result<()> {
-    let overall = state_label(&recommendation.state);
-    ensure!(
-        !recommendation.category.trim().is_empty()
-            && overall.is_some()
-            && !recommendation.investigation.trim().is_empty()
-            && recommendation.comments.iter().all(|comment| {
-                !comment.body.trim().is_empty() && IssueUrl::parse(&comment.url).is_ok()
-            }),
-        INCOMPLETE
-    );
-    for issue in &mut recommendation.issues {
-        issue.questionnaire = issue
-            .questionnaire
-            .take()
-            .filter(|text| !text.trim().is_empty());
-        ensure!(
-            !issue.title.trim().is_empty()
-                && !issue.body.trim().is_empty()
-                && issue
-                    .confirmation_blocked
-                    .as_deref()
-                    .is_none_or(|reason| !reason.trim().is_empty()),
-            INCOMPLETE
-        );
-        let recommended = issue
-            .state
-            .as_deref()
-            .map_or(overall, state_label)
-            .context(INCOMPLETE)?;
-        // Only the Day shift can confirm a problem that needs credentials or
-        // production access, whatever the session recommended.
-        let triaged = if issue.confirmation_blocked.is_some() {
-            labels::READY_FOR_HUMAN
-        } else {
-            recommended
-        };
-        let needs_answer = triaged == labels::NEEDS_INFO;
-        ensure!(
-            issue.questionnaire.is_some() == needs_answer,
-            "the Triage questionnaire is required only for needs-info issues: {}",
-            issue.title
-        );
-        issue.triaged = Some(triaged);
-    }
-    Ok(())
-}
-
-fn state_label(state: &str) -> Option<Label> {
-    std::iter::once(labels::READY_FOR_AGENT)
-        .chain(labels::UNREADY)
-        .find(|label| label.is_named(state))
-}
-
-/// Whether thirdshift treats `name` as workflow state. The session may name
-/// a repository category; these stay factory-owned, whatever their case.
-fn is_factory_label(name: &str) -> bool {
-    state_label(name).is_some()
-        || crate::claim::IN_PROGRESS.is_named(name)
-        || crate::claim::AGENT_FAILED.is_named(name)
-        || crate::base_fix::BASE_FIX.is_named(name)
-        || labels::FLAKY_TEST.is_named(name)
-        || crate::security::fixing::SECURITY_FIX.is_named(name)
-        || crate::architect::is_mark(name)
-        || crate::github::is_security_finding_label(name)
-}
-
-const CATEGORY_ERROR: &str = "the Triage category must be a repository category label, not a triage state or another factory label";
-
-/// The repository's own spelling of a recommended category, matched case-insensitively.
-fn repository_category<'a>(categories: &'a [String], wanted: &str) -> Result<&'a String> {
-    categories
-        .iter()
-        .find(|name| name.eq_ignore_ascii_case(wanted))
-        .context(CATEGORY_ERROR)
-}
-
-/// A proposed issue's own category, or the recommendation's overall one.
-fn issue_category<'a>(
-    categories: &'a [String],
-    recommendation: &Recommendation,
-    issue: &ProposedIssue,
-) -> Result<&'a String> {
-    repository_category(
-        categories,
-        issue
-            .category
-            .as_deref()
-            .unwrap_or(&recommendation.category),
-    )
-}
-
 /// Guidance, correction and publication share the same usable repository categories.
 fn repository_categories(repo: &Repo, github: &GitHub) -> Result<Vec<String>> {
     Ok(github
@@ -367,125 +156,55 @@ impl std::fmt::Display for IncompletePublication {
     }
 }
 
-/// How filing labels one proposed issue.
-struct Filing {
-    /// The repository's category label, spelled as the repository spells it.
-    category: String,
-    state: Label,
-    /// `ready-for-agent` was recommended, but filing lacks permission for it.
-    readiness_held: bool,
-}
-
-/// Everything filing asks GitHub to accept, checked before any write.
-struct Publication {
-    filings: Vec<Filing>,
-    /// The open issues in this repository that the proposed comments go to.
-    targets: Vec<IssueUrl>,
-}
-
-/// Check the recommendation against GitHub, writing nothing. Both modes
-/// check it, so `--recommend-only` refuses exactly what filing would refuse.
-fn check_publication(
+/// Check the comment targets against GitHub, writing nothing. Both modes
+/// check them, so `--recommend-only` refuses exactly what filing would refuse.
+fn check_comment_targets(
     recommendation: &Recommendation,
     repo: &Repo,
-    categories: &[String],
     github: &GitHub,
-    allow_ready_for_agent: bool,
-) -> Result<Publication> {
-    let targets = recommendation
-        .comments
-        .iter()
-        .map(|comment| {
-            let issue = IssueUrl::parse(&comment.url)?;
-            ensure!(
-                issue.owner.eq_ignore_ascii_case(&repo.owner)
-                    && issue.repo.eq_ignore_ascii_case(&repo.name),
-                "the Triage comment must target an issue in {}: {}",
-                repo.slug(),
-                issue.url
-            );
-            ensure!(
-                github.issue_is_open(&issue)?,
-                "the Triage comment must target an open issue: {}",
-                issue.url
-            );
-            Ok(issue)
-        })
-        .collect::<Result<Vec<_>>>()?;
-    if recommendation.issues.is_empty() {
-        return Ok(Publication {
-            filings: Vec::new(),
-            targets,
-        });
+) -> Result<()> {
+    for comment in recommendation.comments() {
+        let issue = comment.target();
+        ensure!(
+            issue.owner.eq_ignore_ascii_case(&repo.owner)
+                && issue.repo.eq_ignore_ascii_case(&repo.name),
+            "the Triage comment must target an issue in {}: {}",
+            repo.slug(),
+            issue.url
+        );
+        ensure!(
+            github.issue_is_open(issue)?,
+            "the Triage comment must target an open issue: {}",
+            issue.url
+        );
     }
-    let filings = recommendation
-        .issues
-        .iter()
-        .map(|issue| {
-            let category = issue_category(categories, recommendation, issue)?;
-            let triaged = issue
-                .triaged
-                .expect("parse_recommendation resolves every proposed issue's state");
-            let readiness_held = triaged == labels::READY_FOR_AGENT && !allow_ready_for_agent;
-            Ok(Filing {
-                category: category.clone(),
-                state: if readiness_held {
-                    labels::NEEDS_TRIAGE
-                } else {
-                    triaged
-                },
-                readiness_held,
-            })
-        })
-        .collect::<Result<Vec<_>>>()?;
-    Ok(Publication { filings, targets })
+    Ok(())
 }
 
-/// File the checked issues and comments. Each write that lands is pushed to
+/// File a Report's issues and comments. Each write that lands is pushed to
 /// `published` as it lands, so a failure partway still names it.
 fn publish(
-    recommendation: &mut Recommendation,
-    publication: Publication,
-    repo: &Repo,
     report: &Report,
+    issues: &mut [recommendation::Issue],
+    comments: &mut [recommendation::Comment],
+    repo: &Repo,
     github: &GitHub,
     published: &mut Vec<IssueUrl>,
 ) -> Result<()> {
     let original_report = report.quoted();
     let mut wontfix = Vec::new();
-    for (issue, filing) in recommendation.issues.iter_mut().zip(publication.filings) {
-        let held = if filing.readiness_held {
-            "\n\nready-for-agent was recommended; needs-triage is applied until the Day shift permits readiness."
-        } else {
-            ""
-        };
-        let blocked = issue
-            .confirmation_blocked
-            .as_deref()
-            .map_or_else(String::new, |reason| {
-                format!("\n\nConfirmation needs the Day shift: {reason}")
-            });
-        let questionnaire = issue
-            .questionnaire
-            .as_deref()
-            .map_or_else(String::new, |text| {
-                format!("\n\n## Questionnaire\n\n{text}")
-            });
-        issue.body = format!(
-            "This issue was generated by AI.\n\n{}{held}{blocked}{questionnaire}\n\n{original_report}",
-            issue.body,
+    for issue in issues {
+        let body = format!(
+            "This issue was generated by AI.\n\n{}{}\n\n{original_report}",
+            issue.body(),
+            issue.notes(),
         );
-        let url = github.create_triaged_issue(
-            repo,
-            &issue.title,
-            &issue.body,
-            &filing.category,
-            filing.state,
-        )?;
-        issue.url = Some(url.url.clone());
-        issue.category = Some(filing.category);
-        issue.state = Some(filing.state.name().into());
-        if filing.state == labels::WONTFIX {
+        let filing = issue.filing();
+        let state = filing.state();
+        let url =
+            github.create_triaged_issue(repo, issue.title(), &body, filing.category(), state)?;
+        issue.record_filed(&url, body);
+        if state == labels::WONTFIX {
             wontfix.push(url.clone());
         }
         published.push(url);
@@ -511,10 +230,11 @@ fn publish(
             &format!("{GENERATED}\n\nClosed as wontfix, as the Triage run recommended. The issue body says why."),
         )?;
     }
-    for (comment, target) in recommendation.comments.iter_mut().zip(publication.targets) {
-        comment.body = format!("{GENERATED}\n\n{}\n\n{original_report}", comment.body);
-        github.comment_issue(&target, &comment.body)?;
-        published.push(target);
+    for comment in comments {
+        let body = format!("{GENERATED}\n\n{}\n\n{original_report}", comment.body());
+        github.comment_issue(comment.target(), &body)?;
+        published.push(comment.target().clone());
+        comment.record_posted(body);
     }
     Ok(())
 }
@@ -539,10 +259,7 @@ pub fn run(
 ) -> Result<Ended, FailedRun> {
     let repo = launch::repo()?;
     command_limit::hold_slot(&repo);
-    let target = match input {
-        Input::Issue(issue) => Some(issue),
-        Input::Report(_) => None,
-    };
+    let target = input.issue();
     logs::started(
         logs::Work::TriageRun {
             repo: &repo,
@@ -575,10 +292,7 @@ fn investigate(
     base: &launch::BaseBranch,
     mut claim: Option<existing::Claim<'_>>,
 ) -> Result<Ended, FailedRun> {
-    let target = match input {
-        Input::Issue(issue) => Some(issue),
-        Input::Report(_) => None,
-    };
+    let target = input.issue();
     let finding_notification = target
         .map(|issue| existing::finding_notification(issue, &GitHub::new()))
         .transpose()?
@@ -605,42 +319,31 @@ fn investigate(
                 (session_prompt, categories)
             }
         };
-        let mut recommendation =
-            correction::recommendation(sessions, &session_prompt, target, &categories)?;
+        let captured = recommendation::Captured {
+            categories: &categories,
+            input,
+            allow_ready_for_agent: options.allow_ready_for_agent,
+        };
+        let mut recommendation = correction::recommendation(sessions, &session_prompt, &captured)?;
         let github = GitHub::new();
-        let publication = check_publication(
-            &recommendation,
-            repo,
-            &categories,
-            &github,
-            options.allow_ready_for_agent,
-        )
-        .and_then(|mut checked| {
+        let publication = check_comment_targets(&recommendation, repo, &github).and_then(|()| {
             if let Some(target) = target {
                 existing::check_target(target, &github)?;
-                if checked.filings[0].readiness_held {
-                    checked.filings[0].state = labels::READY_FOR_HUMAN;
-                }
             }
             if options.recommend_only {
                 return Ok(());
             }
-            match input {
-                Input::Report(report) => publish(
-                    &mut recommendation,
-                    checked,
-                    repo,
+            match recommendation.publishing() {
+                Publishing::Report {
                     report,
-                    &github,
-                    &mut published,
-                ),
-                Input::Issue(target) => existing::publish(
-                    &mut recommendation,
-                    checked,
+                    issues,
+                    comments,
+                } => publish(report, issues, comments, repo, &github, &mut published),
+                Publishing::Existing {
                     target,
-                    &github,
-                    &mut published,
-                ),
+                    issue,
+                    comments,
+                } => existing::publish(target, issue, comments, &github, &mut published),
             }
         });
         let json = serde_json::to_string(&recommendation)?;
diff --git a/src/triage/correction.rs b/src/triage/correction.rs
index 1e710cfb..49f028a1 100644
--- a/src/triage/correction.rs
+++ b/src/triage/correction.rs
@@ -1,23 +1,19 @@
 //! Correct invalid session output once; GitHub checks and publication stay outside this loop.
 
-use anyhow::{Context, Result, bail};
+use anyhow::{Context, Result};
 
-use super::{
-    Recommendation, existing, issue_category, read_recommendation, resolve_recommendation,
-};
-use crate::issue::IssueUrl;
+use super::recommendation::{Captured, Recommendation};
 use crate::prompt;
 use crate::session::{Kind, Purpose, Sessions};
 
-pub(super) fn recommendation(
+pub(super) fn recommendation<'a>(
     sessions: &Sessions<'_>,
     instructions: &str,
-    target: Option<&IssueUrl>,
-    categories: &[String],
-) -> Result<Recommendation> {
+    captured: &Captured<'a>,
+) -> Result<Recommendation<'a>> {
     // An execution failure is not invalid recommendation output.
     let message = sessions.run_to_final_message(Purpose::Ordinary, Kind::Triage, instructions)?;
-    let error = match validate(message.as_deref(), target, categories) {
+    let error = match Recommendation::interpret(message.as_deref(), captured) {
         Ok(recommendation) => return Ok(recommendation),
         Err(error) => error,
     };
@@ -33,7 +29,7 @@ pub(super) fn recommendation(
     let corrected = sessions
         .run_to_final_message(Purpose::Ordinary, Kind::TriageCorrection, &correction)
         .with_context(|| format!("Triage correction could not complete. {retained}"))?;
-    validate(corrected.as_deref(), target, categories).with_context(|| {
+    Recommendation::interpret(corrected.as_deref(), captured).with_context(|| {
         let correction_trace = sessions
             .last_log_of(Kind::TriageCorrection)
             .map(|path| path.display().to_string())
@@ -43,26 +39,3 @@ pub(super) fn recommendation(
         )
     })
 }
-
-fn validate(
-    message: Option<&str>,
-    target: Option<&IssueUrl>,
-    categories: &[String],
-) -> Result<Recommendation> {
-    let mut recommendation = read_recommendation(message)?;
-    // An invalid category is reported with any other error, so one
-    // correction turn hears about both.
-    let category = recommendation
-        .issues
-        .iter()
-        .find_map(|issue| issue_category(categories, &recommendation, issue).err());
-    let checked = resolve_recommendation(&mut recommendation).and_then(|()| match target {
-        Some(target) => existing::check_recommendation(&mut recommendation, target),
-        None => Ok(()),
-    });
-    match (checked, category) {
-        (Ok(()), None) => Ok(recommendation),
-        (Err(error), None) | (Ok(()), Some(error)) => Err(error),
-        (Err(error), Some(category)) => bail!("{error:#}; {category:#}"),
-    }
-}
diff --git a/src/triage/existing.rs b/src/triage/existing.rs
index 6182cbb4..cb235485 100644
--- a/src/triage/existing.rs
+++ b/src/triage/existing.rs
@@ -3,7 +3,7 @@
 
 use anyhow::{Context, Result, ensure};
 
-use super::{Publication, Recommendation, is_factory_label};
+use super::recommendation::{Comment, Issue, is_factory_label, one_line};
 use crate::claim::{AGENT_FAILED, IN_PROGRESS};
 use crate::git::Git;
 use crate::github::GitHub;
@@ -11,6 +11,9 @@ use crate::issue::IssueUrl;
 use crate::labels::{self, Edit, Label};
 use crate::trust::{self, Reads};
 
+/// Opens each comment an existing-issue Triage run posts.
+const AI_TRIAGE: &str = "> *This was generated by AI during triage.*\n\n";
+
 const STATES_AND_CLAIM: [Label; 7] = [
     labels::NEEDS_TRIAGE,
     labels::READY_FOR_HUMAN,
@@ -48,7 +51,7 @@ pub(super) fn finding_notification(issue: &IssueUrl, github: &GitHub) -> Result<
         .then(|| {
             format!(
                 "Security finding: {}\nIssue: {}\nDetails remain on the private issue and in the Command log.\n",
-                super::one_line(current.title.as_deref().unwrap_or("Security finding")),
+                one_line(current.title.as_deref().unwrap_or("Security finding")),
                 issue.url
             )
         }))
@@ -132,51 +135,16 @@ impl Drop for Claim<'_> {
     }
 }
 
-pub(super) fn check_recommendation(
-    recommendation: &mut Recommendation,
-    target: &IssueUrl,
-) -> Result<()> {
-    ensure!(
-        recommendation.issues.len() == 1,
-        "existing-issue Triage requires exactly one recommendation issue; propose splits in a ready-for-human issue body"
-    );
-    let issue = &mut recommendation.issues[0];
-    ensure!(
-        issue.triaged != Some(labels::NEEDS_TRIAGE),
-        "existing-issue Triage must recommend ready-for-agent, ready-for-human, needs-info or wontfix"
-    );
-    if issue.triaged == Some(labels::READY_FOR_AGENT) {
-        ensure!(
-            issue
-                .body
-                .lines()
-                .any(|line| line.trim() == "## Agent Brief"),
-            "existing-issue ready-for-agent requires ## Agent Brief"
-        );
-    }
-    ensure!(
-        recommendation.comments.iter().all(|comment| {
-            IssueUrl::parse(&comment.url).is_ok_and(|issue| {
-                issue.number != target.number
-                    || !issue.owner.eq_ignore_ascii_case(&target.owner)
-                    || !issue.repo.eq_ignore_ascii_case(&target.repo)
-            })
-        }),
-        "the target issue's single recommendation entry supplies its comment"
-    );
-    issue.url = Some(target.url.clone());
-    Ok(())
-}
-
+/// Publish the single recommendation entry in place: comment, relabel while
+/// keeping an existing category, close `wontfix`, then comment elsewhere.
 pub(super) fn publish(
-    recommendation: &mut Recommendation,
-    publication: Publication,
     target: &IssueUrl,
+    issue: &mut Issue,
+    comments: &mut [Comment],
     github: &GitHub,
     published: &mut Vec<IssueUrl>,
 ) -> Result<()> {
-    let issue = &mut recommendation.issues[0];
-    let filing = &publication.filings[0];
+    let filing = issue.filing();
     let current = github.issue_labels(target)?;
     let categories: Vec<_> = current
         .names()
@@ -185,42 +153,27 @@ pub(super) fn publish(
     let category = categories
         .first()
         .copied()
-        .unwrap_or(&filing.category)
+        .unwrap_or(filing.category())
         .to_string();
-    let mut body = format!(
-        "> *This was generated by AI during triage.*\n\n{}",
-        issue.body
-    );
-    if filing.readiness_held {
-        body.push_str("\n\nready-for-agent was recommended; ready-for-human is applied until the Day shift permits readiness.");
-    }
-    if let Some(reason) = &issue.confirmation_blocked {
-        body.push_str(&format!("\n\nConfirmation needs the Day shift: {reason}"));
-    }
-    if let Some(questionnaire) = &issue.questionnaire {
-        body.push_str(&format!("\n\n## Questionnaire\n\n{questionnaire}"));
-    }
+    let body = format!("{AI_TRIAGE}{}{}", issue.body(), issue.notes());
     github.comment_issue(target, &body)?;
     published.push(target.clone());
+    let state = filing.state();
     let add_category = categories.is_empty();
-    let mut edit = Edit::of(target, current, &STATES_AND_CLAIM, &[filing.state]);
+    let mut edit = Edit::of(target, current, &STATES_AND_CLAIM, &[state]);
     if add_category {
-        edit = edit.with_repository_label(&filing.category);
+        edit = edit.with_repository_label(filing.category());
     }
     edit.apply(github)?;
-    issue.body = body;
-    issue.category = Some(category);
-    issue.state = Some(filing.state.name().into());
-    if filing.state == labels::WONTFIX {
+    issue.record_in_place(body, category);
+    if state == labels::WONTFIX {
         github.close_triaged_issue(target)?;
     }
-    for (comment, target) in recommendation.comments.iter_mut().zip(publication.targets) {
-        comment.body = format!(
-            "> *This was generated by AI during triage.*\n\n{}",
-            comment.body
-        );
-        github.comment_issue(&target, &comment.body)?;
-        published.push(target);
+    for comment in comments {
+        let body = format!("{AI_TRIAGE}{}", comment.body());
+        github.comment_issue(comment.target(), &body)?;
+        published.push(comment.target().clone());
+        comment.record_posted(body);
     }
     Ok(())
 }
diff --git a/src/triage/recommendation.rs b/src/triage/recommendation.rs
new file mode 100644
index 00000000..12cbf3b5
--- /dev/null
+++ b/src/triage/recommendation.rs
@@ -0,0 +1,564 @@
+//! A Triage run's recommendation, interpreted once from the session's final
+//! message. The initial session and its correction, `--recommend-only` and
+//! both publications share the result: each proposed issue keeps its filing
+//! category, state and readiness, and each proposed comment its target.
+//! GitHub reads and writes stay with the callers.
+
+use anyhow::{Context, Result, bail, ensure};
+use serde::{Deserialize, Serialize};
+
+use super::{Input, Report};
+use crate::issue::IssueUrl;
+use crate::labels::{self, Label};
+
+/// Everything interpretation needs besides the session's message, all
+/// captured before the session.
+pub(super) struct Captured<'a> {
+    /// The repository's category labels, as captured for the session.
+    pub categories: &'a [String],
+    /// The Report to file from, or the existing issue to triage in place.
+    pub input: &'a Input,
+    /// Filing may keep a recommended `ready-for-agent`.
+    pub allow_ready_for_agent: bool,
+}
+
+const INCOMPLETE: &str = "the Triage recommendation needs a category, triage state, investigation and complete proposed issues or comments";
+const CATEGORY_ERROR: &str = "the Triage category must be a repository category label, not a triage state or another factory label";
+const ONE_ISSUE: &str = "existing-issue Triage requires exactly one recommendation issue; propose splits in a ready-for-human issue body";
+
+/// The recommendation line as the session writes it.
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct Wire {
+    category: String,
+    state: String,
+    issues: Vec<ProposedIssue>,
+    #[serde(default)]
+    comments: Vec<ProposedComment>,
+    investigation: String,
+}
+
+/// A proposed issue as recommended, updated only with what publication did.
+#[derive(Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+struct ProposedIssue {
+    title: String,
+    body: String,
+    #[serde(skip_deserializing, skip_serializing_if = "Option::is_none")]
+    url: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    category: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    state: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    confirmation_blocked: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    questionnaire: Option<String>,
+}
+
+#[derive(Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+struct ProposedComment {
+    url: String,
+    body: String,
+}
+
+/// A valid recommendation, with each proposal's resolved facts beside it.
+pub(super) struct Recommendation<'a> {
+    category: String,
+    state: String,
+    investigation: String,
+    proposals: Proposals<'a>,
+    comments: Vec<Comment>,
+}
+
+enum Proposals<'a> {
+    Report {
+        report: &'a Report,
+        issues: Vec<Issue>,
+    },
+    Existing {
+        target: &'a IssueUrl,
+        issue: Box<Issue>,
+    },
+}
+
+/// One proposed issue and how it is filed.
+pub(super) struct Issue {
+    proposed: ProposedIssue,
+    filing: Filing,
+}
+
+/// How a proposed issue is labelled.
+pub(super) struct Filing {
+    /// The repository's category label, spelled as the repository spells it.
+    category: String,
+    /// The recommended state, after a confirmation block.
+    triaged: Label,
+    /// The state applied, after readiness permission.
+    state: Label,
+}
+
+/// One proposed comment and the issue it goes to.
+pub(super) struct Comment {
+    proposed: ProposedComment,
+    target: IssueUrl,
+}
+
+/// The proposals as one mode publishes them.
+pub(super) enum Publishing<'r, 'a> {
+    Report {
+        report: &'a Report,
+        issues: &'r mut [Issue],
+        comments: &'r mut [Comment],
+    },
+    Existing {
+        target: &'a IssueUrl,
+        issue: &'r mut Issue,
+        comments: &'r mut [Comment],
+    },
+}
+
+impl<'a> Recommendation<'a> {
+    /// Interpret the session's final `Triage recommendation:` line. A
+    /// category error is reported with any other error, so one correction
+    /// turn hears about both.
+    pub fn interpret(message: Option<&str>, captured: &Captured<'a>) -> Result<Self> {
+        let wire = read(message)?;
+        let categories = wire
+            .issues
+            .iter()
+            .map(|issue| {
+                repository_category(
+                    captured.categories,
+                    issue.category.as_deref().unwrap_or(&wire.category),
+                )
+            })
+            .collect::<Result<Vec<_>>>();
+        let target = captured.input.issue();
+        let (resolved, categories) = match (resolve(wire, target), categories) {
+            (Ok(resolved), Ok(categories)) => (resolved, categories),
+            (Err(error), Ok(_)) | (Ok(_), Err(error)) => return Err(error),
+            (Err(error), Err(category)) => bail!("{error:#}; {category:#}"),
+        };
+        // An unpermitted readiness waits for the Day shift: a Report's issue
+        // is triaged again, an existing issue goes to a human.
+        let held = match target {
+            None => labels::NEEDS_TRIAGE,
+            Some(_) => labels::READY_FOR_HUMAN,
+        };
+        // Both are built from the same proposed issues, one entry each.
+        let mut issues =
+            resolved
+                .issues
+                .into_iter()
+                .zip(categories)
+                .map(|((proposed, triaged), category)| Issue {
+                    proposed,
+                    filing: Filing {
+                        category: category.clone(),
+                        triaged,
+                        state: if triaged == labels::READY_FOR_AGENT
+                            && !captured.allow_ready_for_agent
+                        {
+                            held
+                        } else {
+                            triaged
+                        },
+                    },
+                });
+        let proposals = match captured.input {
+            Input::Report(report) => Proposals::Report {
+                report,
+                issues: issues.collect(),
+            },
+            Input::Issue(target) => {
+                let mut issue = issues
+                    .next()
+                    .expect("resolve gives an existing target exactly one issue");
+                issue.proposed.url = Some(target.url.clone());
+                Proposals::Existing {
+                    target,
+                    issue: Box::new(issue),
+                }
+            }
+        };
+        Ok(Recommendation {
+            category: resolved.category,
+            state: resolved.state,
+            investigation: resolved.investigation,
+            proposals,
+            comments: resolved.comments,
+        })
+    }
+
+    /// The proposed comments, each with its parsed target, for the GitHub
+    /// checks made before any write.
+    pub fn comments(&self) -> &[Comment] {
+        &self.comments
+    }
+
+    /// The proposals as this recommendation's mode publishes them.
+    pub fn publishing(&mut self) -> Publishing<'_, 'a> {
+        match &mut self.proposals {
+            Proposals::Report { report, issues } => Publishing::Report {
+                report,
+                issues,
+                comments: &mut self.comments,
+            },
+            Proposals::Existing { target, issue } => Publishing::Existing {
+                target,
+                issue,
+                comments: &mut self.comments,
+            },
+        }
+    }
+
+    fn issues(&self) -> &[Issue] {
+        match &self.proposals {
+            Proposals::Report { issues, .. } => issues,
+            Proposals::Existing { issue, .. } => std::slice::from_ref(issue.as_ref()),
+        }
+    }
+
+    /// A readable Run notification, leaving full issue and comment bodies on stdout.
+    /// Fields stay inside their records: a line break in session text must not
+    /// open another `Issue:` line, and terminal controls must not be written out.
+    pub fn notification(&self) -> String {
+        let mut notification = format!(
+            "Investigation:\n{}\n\nRecommendation: {} ({})\n",
+            investigation_text(&self.investigation),
+            one_line(&self.category),
+            one_line(&self.state)
+        );
+        let issues = self.issues();
+        if !issues.is_empty() {
+            notification.push_str("\nIssues:\n");
+            for issue in issues.iter().map(|issue| &issue.proposed) {
+                notification.push_str(&format!(
+                    "- {} ({}, {})\n",
+                    one_line(&issue.title),
+                    one_line(issue.category.as_deref().unwrap_or(&self.category)),
+                    one_line(issue.state.as_deref().unwrap_or(&self.state))
+                ));
+                if let Some(url) = &issue.url {
+                    notification.push_str(&format!("Issue: {}\n", one_line(url)));
+                }
+            }
+        }
+        if !self.comments.is_empty() {
+            notification.push_str("\nComment targets:\n");
+            for comment in &self.comments {
+                notification.push_str(&format!("- {}\n", one_line(&comment.proposed.url)));
+            }
+        }
+        for issue in issues.iter().map(|issue| &issue.proposed) {
+            if let Some(questionnaire) = &issue.questionnaire {
+                notification.push_str(&format!("\nQuestionnaire: {}\n", one_line(&issue.title)));
+                if let Some(url) = &issue.url {
+                    notification.push_str(&format!("Issue: {}\n", one_line(url)));
+                }
+                notification.push_str(&format!("\n{questionnaire}\n"));
+            }
+        }
+        notification
+    }
+}
+
+/// Stdout's recommendation JSON: as recommended, with what publication did.
+impl Serialize for Recommendation<'_> {
+    fn serialize<S: serde::Serializer>(
+        &self,
+        serializer: S,
+    ) -> std::result::Result<S::Ok, S::Error> {
+        #[derive(Serialize)]
+        struct Output<'r> {
+            category: &'r str,
+            state: &'r str,
+            issues: Vec<&'r ProposedIssue>,
+            #[serde(skip_serializing_if = "Vec::is_empty")]
+            comments: Vec<&'r ProposedComment>,
+            investigation: &'r str,
+        }
+        Output {
+            category: &self.category,
+            state: &self.state,
+            issues: self.issues().iter().map(|issue| &issue.proposed).collect(),
+            comments: self
+                .comments
+                .iter()
+                .map(|comment| &comment.proposed)
+                .collect(),
+            investigation: &self.investigation,
+        }
+        .serialize(serializer)
+    }
+}
+
+impl Issue {
+    pub fn title(&self) -> &str {
+        &self.proposed.title
+    }
+
+    /// The body the session proposed.
+    pub fn body(&self) -> &str {
+        &self.proposed.body
+    }
+
+    /// What publication adds after the proposed body: a held readiness, a
+    /// confirmation only the Day shift can make and any questionnaire.
+    pub fn notes(&self) -> String {
+        let mut notes = String::new();
+        if self.filing.readiness_held() {
+            notes.push_str(&format!(
+                "\n\nready-for-agent was recommended; {} is applied until the Day shift permits readiness.",
+                self.filing.state
+            ));
+        }
+        if let Some(reason) = &self.proposed.confirmation_blocked {
+            notes.push_str(&format!("\n\nConfirmation needs the Day shift: {reason}"));
+        }
+        if let Some(questionnaire) = &self.proposed.questionnaire {
+            notes.push_str(&format!("\n\n## Questionnaire\n\n{questionnaire}"));
+        }
+        notes
+    }
+
+    pub fn filing(&self) -> &Filing {
+        &self.filing
+    }
+
+    /// Record a Report's issue once filed: its URL, the body it was filed
+    /// with, and the category and state it was filed under.
+    pub fn record_filed(&mut self, issue: &IssueUrl, body: String) {
+        self.proposed.url = Some(issue.url.clone());
+        self.record(body, self.filing.category.clone());
+    }
+
+    /// Record an existing issue once relabelled: the comment it was given
+    /// and the category it keeps.
+    pub fn record_in_place(&mut self, body: String, category: String) {
+        self.record(body, category);
+    }
+
+    fn record(&mut self, body: String, category: String) {
+        self.proposed.body = body;
+        self.proposed.category = Some(category);
+        self.proposed.state = Some(self.filing.state.name().into());
+    }
+}
+
+impl Filing {
+    pub fn category(&self) -> &str {
+        &self.category
+    }
+
+    pub fn state(&self) -> Label {
+        self.state
+    }
+
+    /// `ready-for-agent` was recommended, but filing lacks permission for it.
+    fn readiness_held(&self) -> bool {
+        self.triaged == labels::READY_FOR_AGENT && self.state != labels::READY_FOR_AGENT
+    }
+}
+
+impl Comment {
+    pub fn target(&self) -> &IssueUrl {
+        &self.target
+    }
+
+    /// The body the session proposed.
+    pub fn body(&self) -> &str {
+        &self.proposed.body
+    }
+
+    /// Record the body a landed comment was posted with.
+    pub fn record_posted(&mut self, body: String) {
+        self.proposed.body = body;
+    }
+}
+
+/// Read the session's final recommendation line. The session's prose stays
+/// out of the machine-readable stdout contract.
+fn read(message: Option<&str>) -> Result<Wire> {
+    let json = message
+        .and_then(|message| {
+            message
+                .lines()
+                .rev()
+                .find_map(|line| line.strip_prefix("Triage recommendation: "))
+        })
+        .context("the Triage session ended without its final Triage recommendation: JSON line")?;
+    serde_json::from_str(json).context("the Triage recommendation is not valid recommendation JSON")
+}
+
+/// A complete recommendation, each proposed issue with its triaged state.
+struct Resolved {
+    category: String,
+    state: String,
+    investigation: String,
+    issues: Vec<(ProposedIssue, Label)>,
+    comments: Vec<Comment>,
+}
+
+/// Check the recommendation is complete and resolve each proposed issue's
+/// state; an existing `target` adds its own rules.
+fn resolve(wire: Wire, target: Option<&IssueUrl>) -> Result<Resolved> {
+    let Wire {
+        category,
+        state,
+        issues,
+        comments,
+        investigation,
+    } = wire;
+    let overall = state_label(&state)
+        .filter(|_| !category.trim().is_empty() && !investigation.trim().is_empty())
+        .context(INCOMPLETE)?;
+    let comments = comments
+        .into_iter()
+        .map(|proposed| {
+            let target = IssueUrl::parse(&proposed.url)
+                .ok()
+                .filter(|_| !proposed.body.trim().is_empty())?;
+            Some(Comment { proposed, target })
+        })
+        .collect::<Option<Vec<_>>>()
+        .context(INCOMPLETE)?;
+    let issues = issues
+        .into_iter()
+        .map(|issue| resolve_issue(issue, overall))
+        .collect::<Result<Vec<_>>>()?;
+    if let Some(target) = target {
+        check_existing(&issues, &comments, target)?;
+    }
+    Ok(Resolved {
+        category,
+        state,
+        investigation,
+        issues,
+        comments,
+    })
+}
+
+fn resolve_issue(mut issue: ProposedIssue, overall: Label) -> Result<(ProposedIssue, Label)> {
+    issue.questionnaire = issue
+        .questionnaire
+        .take()
+        .filter(|text| !text.trim().is_empty());
+    ensure!(
+        !issue.title.trim().is_empty()
+            && !issue.body.trim().is_empty()
+            && issue
+                .confirmation_blocked
+                .as_deref()
+                .is_none_or(|reason| !reason.trim().is_empty()),
+        INCOMPLETE
+    );
+    let recommended = issue
+        .state
+        .as_deref()
+        .map_or(Some(overall), state_label)
+        .context(INCOMPLETE)?;
+    // Only the Day shift can confirm a problem that needs credentials or
+    // production access, whatever the session recommended.
+    let triaged = if issue.confirmation_blocked.is_some() {
+        labels::READY_FOR_HUMAN
+    } else {
+        recommended
+    };
+    ensure!(
+        issue.questionnaire.is_some() == (triaged == labels::NEEDS_INFO),
+        "the Triage questionnaire is required only for needs-info issues: {}",
+        issue.title
+    );
+    Ok((issue, triaged))
+}
+
+fn check_existing(
+    issues: &[(ProposedIssue, Label)],
+    comments: &[Comment],
+    target: &IssueUrl,
+) -> Result<()> {
+    let [(issue, triaged)] = issues else {
+        bail!(ONE_ISSUE);
+    };
+    ensure!(
+        *triaged != labels::NEEDS_TRIAGE,
+        "existing-issue Triage must recommend ready-for-agent, ready-for-human, needs-info or wontfix"
+    );
+    if *triaged == labels::READY_FOR_AGENT {
+        ensure!(
+            issue
+                .body
+                .lines()
+                .any(|line| line.trim() == "## Agent Brief"),
+            "existing-issue ready-for-agent requires ## Agent Brief"
+        );
+    }
+    ensure!(
+        comments.iter().all(|comment| {
+            comment.target.number != target.number || !comment.target.in_same_repo(target)
+        }),
+        "the target issue's single recommendation entry supplies its comment"
+    );
+    Ok(())
+}
+
+fn state_label(state: &str) -> Option<Label> {
+    std::iter::once(labels::READY_FOR_AGENT)
+        .chain(labels::UNREADY)
+        .find(|label| label.is_named(state))
+}
+
+/// Whether thirdshift treats `name` as workflow state. The session may name
+/// a repository category; these stay factory-owned, whatever their case.
+pub(super) fn is_factory_label(name: &str) -> bool {
+    state_label(name).is_some()
+        || crate::claim::IN_PROGRESS.is_named(name)
+        || crate::claim::AGENT_FAILED.is_named(name)
+        || crate::base_fix::BASE_FIX.is_named(name)
+        || labels::FLAKY_TEST.is_named(name)
+        || crate::security::fixing::SECURITY_FIX.is_named(name)
+        || crate::architect::is_mark(name)
+        || crate::github::is_security_finding_label(name)
+}
+
+/// The repository's own spelling of a recommended category, matched case-insensitively.
+fn repository_category<'c>(categories: &'c [String], wanted: &str) -> Result<&'c String> {
+    categories
+        .iter()
+        .find(|name| name.eq_ignore_ascii_case(wanted))
+        .context(CATEGORY_ERROR)
+}
+
+/// One notification field. Line breaks and terminal controls would otherwise
+/// open another record, such as a forged `Issue:` line.
+pub(super) fn one_line(text: &str) -> String {
+    let mut collapsed = String::with_capacity(text.len());
+    let mut pending_space = false;
+    for ch in text.chars() {
+        if ch == '\u{2028}' || ch == '\u{2029}' || ch.is_control() {
+            pending_space = !collapsed.is_empty();
+            continue;
+        }
+        if pending_space {
+            collapsed.push(' ');
+            pending_space = false;
+        }
+        collapsed.push(ch);
+    }
+    collapsed
+}
+
+/// The investigation, one indented line per row, so none of its text stands
+/// as its own notification record.
+fn investigation_text(text: &str) -> String {
+    text.split('\n')
+        .map(|line| format!("  {}", one_line(line)))
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/src/triage/recommendation/tests.rs b/src/triage/recommendation/tests.rs
new file mode 100644
index 00000000..d9efc2f3
--- /dev/null
+++ b/src/triage/recommendation/tests.rs
@@ -0,0 +1,477 @@
+use std::sync::LazyLock;
+
+use anyhow::Result;
+use serde_json::{Value, json};
+
+use super::{Captured, Publishing, Recommendation};
+use crate::issue::IssueUrl;
+use crate::labels;
+use crate::triage::{Input, Report};
+
+static CATEGORIES: LazyLock<Vec<String>> =
+    LazyLock::new(|| vec!["Bug".to_owned(), "Enhancement".to_owned()]);
+
+fn report() -> Input {
+    Input::Report(Report {
+        text: "The export button does nothing.".into(),
+        file: None,
+    })
+}
+
+fn existing() -> Input {
+    Input::Issue(IssueUrl::parse("https://github.com/owner/repo/issues/7").unwrap())
+}
+
+fn interpret(
+    input: &Input,
+    allow_ready_for_agent: bool,
+    line: Value,
+) -> Result<Recommendation<'_>> {
+    let message = format!("Investigated.\nTriage recommendation: {line}");
+    Recommendation::interpret(
+        Some(&message),
+        &Captured {
+            categories: &CATEGORIES,
+            input,
+            allow_ready_for_agent,
+        },
+    )
+}
+
+fn output(recommendation: &Recommendation<'_>) -> Value {
+    serde_json::to_value(recommendation).unwrap()
+}
+
+/// Each Report issue's category, applied state and held readiness, in order.
+fn report_filings(recommendation: &mut Recommendation<'_>) -> Vec<(String, &'static str, bool)> {
+    let Publishing::Report { issues, .. } = recommendation.publishing() else {
+        panic!("a Report recommendation publishes as a Report");
+    };
+    issues
+        .iter()
+        .map(|issue| {
+            let filing = issue.filing();
+            (
+                filing.category().to_owned(),
+                filing.state().name(),
+                filing.readiness_held(),
+            )
+        })
+        .collect()
+}
+
+#[test]
+fn report_issues_resolve_category_and_state_fallbacks_without_rewriting_the_recommendation() {
+    let input = report();
+    let line = json!({
+        "category": "bug",
+        "state": "ready-for-agent",
+        "issues": [
+            {"title": "Fallbacks", "body": "Uses the overall values."},
+            {"title": "Own values", "body": "Overrides both.", "category": "ENHANCEMENT", "state": "Ready-For-Human"},
+            {"title": "Blocked", "body": "Needs production.", "confirmation_blocked": "needs production access"},
+            {"title": "Ask", "body": "Unclear.", "state": "needs-info", "questionnaire": "Which browser?"}
+        ],
+        "investigation": "Looked at the exporter."
+    });
+    let mut recommendation = interpret(&input, false, line.clone()).unwrap();
+
+    assert_eq!(
+        report_filings(&mut recommendation),
+        [
+            ("Bug".to_owned(), "needs-triage", true),
+            ("Enhancement".to_owned(), "ready-for-human", false),
+            ("Bug".to_owned(), "ready-for-human", false),
+            ("Bug".to_owned(), "needs-info", false),
+        ]
+    );
+    // Recommend-only prints what the session recommended, not filing values.
+    assert_eq!(output(&recommendation), line);
+}
+
+#[test]
+fn permitted_readiness_files_ready_for_agent() {
+    let input = report();
+    let mut recommendation = interpret(
+        &input,
+        true,
+        json!({
+            "category": "Bug",
+            "state": "ready-for-agent",
+            "issues": [{"title": "Fix export", "body": "## Agent Brief"}],
+            "investigation": "Found it."
+        }),
+    )
+    .unwrap();
+
+    assert_eq!(
+        report_filings(&mut recommendation),
+        [("Bug".to_owned(), "ready-for-agent", false)]
+    );
+}
+
+#[test]
+fn existing_target_holds_unpermitted_readiness_for_a_human_and_names_the_target() {
+    let input = existing();
+    let mut recommendation = interpret(
+        &input,
+        false,
+        json!({
+            "category": "enhancement",
+            "state": "ready-for-agent",
+            "issues": [{"title": "Export", "body": "Plan.\n## Agent Brief\nDo it."}],
+            "comments": [{"url": "https://github.com/owner/repo/issues/8", "body": "Related."}],
+            "investigation": "Found it."
+        }),
+    )
+    .unwrap();
+
+    let serialized = output(&recommendation);
+    assert_eq!(
+        serialized["issues"][0]["url"],
+        "https://github.com/owner/repo/issues/7"
+    );
+    assert_eq!(serialized["state"], "ready-for-agent");
+    assert!(serialized["issues"][0].get("state").is_none());
+    let targets: Vec<_> = recommendation
+        .comments()
+        .iter()
+        .map(|comment| comment.target().number)
+        .collect();
+    assert_eq!(targets, [8]);
+    let Publishing::Existing {
+        target,
+        issue,
+        comments,
+    } = recommendation.publishing()
+    else {
+        panic!("an existing-issue recommendation publishes in place");
+    };
+    assert_eq!(target.number, 7);
+    assert_eq!(comments.len(), 1);
+    let filing = issue.filing();
+    assert_eq!(
+        (filing.category(), filing.state(), filing.readiness_held()),
+        ("Enhancement", labels::READY_FOR_HUMAN, true)
+    );
+}
+
+#[test]
+fn existing_target_requires_an_agent_brief_even_when_readiness_is_held() {
+    let input = existing();
+    let error = interpret(
+        &input,
+        false,
+        json!({
+            "category": "Bug",
+            "state": "ready-for-agent",
+            "issues": [{"title": "Export", "body": "No brief."}],
+            "investigation": "Found it."
+        }),
+    )
+    .err()
+    .unwrap();
+
+    assert_eq!(
+        format!("{error:#}"),
+        "existing-issue ready-for-agent requires ## Agent Brief"
+    );
+}
+
+#[test]
+fn existing_target_confirmation_block_needs_no_agent_brief() {
+    let input = existing();
+    let mut recommendation = interpret(
+        &input,
+        true,
+        json!({
+            "category": "Bug",
+            "state": "ready-for-agent",
+            "issues": [{"title": "Export", "body": "No brief.", "confirmation_blocked": "needs credentials"}],
+            "investigation": "Found it."
+        }),
+    )
+    .unwrap();
+
+    let Publishing::Existing { issue, .. } = recommendation.publishing() else {
+        panic!("an existing-issue recommendation publishes in place");
+    };
+    assert_eq!(issue.filing().state(), labels::READY_FOR_HUMAN);
+    assert!(!issue.filing().readiness_held());
+}
+
+#[test]
+fn existing_target_rules_reject_other_shapes() {
+    let input = existing();
+    let cases = [
+        (
+            json!({"category": "Bug", "state": "ready-for-human", "issues": [], "investigation": "x"}),
+            "existing-issue Triage requires exactly one recommendation issue; propose splits in a ready-for-human issue body",
+        ),
+        (
+            json!({"category": "Bug", "state": "needs-triage", "issues": [{"title": "t", "body": "b"}], "investigation": "x"}),
+            "existing-issue Triage must recommend ready-for-agent, ready-for-human, needs-info or wontfix",
+        ),
+        (
+            json!({
+                "category": "Bug",
+                "state": "ready-for-human",
+                "issues": [{"title": "t", "body": "b"}],
+                "comments": [{"url": "https://github.com/Owner/Repo/issues/7", "body": "Self."}],
+                "investigation": "x"
+            }),
+            "the target issue's single recommendation entry supplies its comment",
+        ),
+    ];
+    for (line, expected) in cases {
+        let error = interpret(&input, true, line).err().unwrap();
+        assert_eq!(format!("{error:#}"), expected);
+    }
+}
+
+#[test]
+fn questionnaires_are_normalized_and_required_only_for_needs_info() {
+    let input = report();
+    let recommendation = interpret(
+        &input,
+        true,
+        json!({
+            "category": "Bug",
+            "state": "ready-for-human",
+            "issues": [{"title": "Blank", "body": "b", "questionnaire": "  \n "}],
+            "investigation": "x"
+        }),
+    )
+    .unwrap();
+    assert!(
+        output(&recommendation)["issues"][0]
+            .get("questionnaire")
+            .is_none()
+    );
+
+    let cases = [
+        json!({"category": "Bug", "state": "needs-info", "issues": [{"title": "Ask", "body": "b", "questionnaire": " "}], "investigation": "x"}),
+        json!({"category": "Bug", "state": "ready-for-human", "issues": [{"title": "Ask", "body": "b", "questionnaire": "Which?"}], "investigation": "x"}),
+        json!({"category": "Bug", "state": "needs-info", "issues": [{"title": "Ask", "body": "b", "questionnaire": "Which?", "confirmation_blocked": "needs production"}], "investigation": "x"}),
+    ];
+    for line in cases {
+        let error = interpret(&input, true, line).err().unwrap();
+        assert_eq!(
+            format!("{error:#}"),
+            "the Triage questionnaire is required only for needs-info issues: Ask"
+        );
+    }
+}
+
+#[test]
+fn a_category_error_is_reported_with_a_structural_error() {
+    let input = existing();
+    let error = interpret(
+        &input,
+        true,
+        json!({
+            "category": "needs-info",
+            "state": "ready-for-human",
+            "issues": [{"title": "One", "body": "b"}, {"title": "Two", "body": "b"}],
+            "investigation": "x"
+        }),
+    )
+    .err()
+    .unwrap();
+
+    assert_eq!(
+        format!("{error:#}"),
+        "existing-issue Triage requires exactly one recommendation issue; propose splits in a ready-for-human issue body; the Triage category must be a repository category label, not a triage state or another factory label"
+    );
+}
+
+#[test]
+fn incomplete_recommendations_and_unreadable_lines_are_diagnosed() {
+    let input = report();
+    let incomplete = "the Triage recommendation needs a category, triage state, investigation and complete proposed issues or comments";
+    let cases = [
+        json!({"category": " ", "state": "wontfix", "issues": [], "investigation": "x"}),
+        json!({"category": "Bug", "state": "maybe", "issues": [], "investigation": "x"}),
+        json!({"category": "Bug", "state": "wontfix", "issues": [{"title": " ", "body": "b"}], "investigation": "x"}),
+        json!({"category": "Bug", "state": "wontfix", "issues": [{"title": "t", "body": "b", "state": "later"}], "investigation": "x"}),
+        json!({"category": "Bug", "state": "wontfix", "issues": [], "comments": [{"url": "not a url", "body": "b"}], "investigation": "x"}),
+    ];
+    for line in cases {
+        let error = interpret(&input, true, line).err().unwrap();
+        assert_eq!(format!("{error}"), incomplete);
+    }
+    let context = Captured {
+        categories: &CATEGORIES,
+        input: &input,
+        allow_ready_for_agent: true,
+    };
+    let missing = Recommendation::interpret(Some("No recommendation."), &context)
+        .err()
+        .unwrap();
+    assert_eq!(
+        format!("{missing}"),
+        "the Triage session ended without its final Triage recommendation: JSON line"
+    );
+}
+
+#[test]
+fn a_comment_only_report_accepts_any_category() {
+    let input = report();
+    let line = json!({
+        "category": "Not a label",
+        "state": "wontfix",
+        "issues": [],
+        "comments": [{"url": "https://github.com/owner/repo/issues/3", "body": "Duplicate."}],
+        "investigation": "Already reported."
+    });
+    let recommendation = interpret(&input, false, line.clone()).unwrap();
+
+    assert_eq!(output(&recommendation), line);
+    assert_eq!(recommendation.comments()[0].target().number, 3);
+}
+
+#[test]
+fn recorded_publication_reaches_output_and_notification() {
+    let input = report();
+    let mut recommendation = interpret(
+        &input,
+        false,
+        json!({
+            "category": "bug",
+            "state": "ready-for-agent",
+            "issues": [{"title": "Fix\nIssue: forged", "body": "b"}],
+            "comments": [{"url": "https://github.com/owner/repo/issues/3", "body": "See."}],
+            "investigation": "Line one\nIssue: forged"
+        }),
+    )
+    .unwrap();
+    assert_eq!(
+        recommendation.notification(),
+        "Investigation:\n  Line one\n  Issue: forged\n\nRecommendation: bug (ready-for-agent)\n\nIssues:\n- Fix Issue: forged (bug, ready-for-agent)\n\nComment targets:\n- https://github.com/owner/repo/issues/3\n"
+    );
+
+    let filed = IssueUrl::parse("https://github.com/owner/repo/issues/9").unwrap();
+    let Publishing::Report {
+        issues, comments, ..
+    } = recommendation.publishing()
+    else {
+        panic!("a Report recommendation publishes as a Report");
+    };
+    issues[0].record_filed(&filed, "Filed body".into());
+    comments[0].record_posted("Posted body".into());
+
+    let serialized = output(&recommendation);
+    assert_eq!(
+        serialized["issues"][0],
+        json!({
+            "title": "Fix\nIssue: forged",
+            "body": "Filed body",
+            "url": "https://github.com/owner/repo/issues/9",
+            "category": "Bug",
+            "state": "needs-triage"
+        })
+    );
+    assert_eq!(serialized["comments"][0]["body"], "Posted body");
+    assert!(recommendation.notification().contains(
+        "- Fix Issue: forged (Bug, needs-triage)\nIssue: https://github.com/owner/repo/issues/9\n"
+    ));
+}
+
+#[test]
+fn a_report_category_error_is_reported_with_an_incomplete_issue() {
+    let input = report();
+    let error = interpret(
+        &input,
+        true,
+        json!({
+            "category": "Bug",
+            "state": "ready-for-human",
+            "issues": [{"title": " ", "body": "b"}, {"title": "t", "body": "b", "category": "wontfix"}],
+            "investigation": "x"
+        }),
+    )
+    .err()
+    .unwrap();
+
+    assert_eq!(
+        format!("{error:#}"),
+        "the Triage recommendation needs a category, triage state, investigation and complete proposed issues or comments; the Triage category must be a repository category label, not a triage state or another factory label"
+    );
+}
+
+#[test]
+fn existing_target_keeps_permitted_readiness() {
+    let input = existing();
+    let mut recommendation = interpret(
+        &input,
+        true,
+        json!({
+            "category": "Bug",
+            "state": "ready-for-agent",
+            "issues": [{"title": "Export", "body": "## Agent Brief\nDo it."}],
+            "investigation": "Found it."
+        }),
+    )
+    .unwrap();
+
+    let Publishing::Existing { issue, .. } = recommendation.publishing() else {
+        panic!("an existing-issue recommendation publishes in place");
+    };
+    assert_eq!(issue.filing().state(), labels::READY_FOR_AGENT);
+    assert!(!issue.filing().readiness_held());
+    assert_eq!(issue.notes(), "");
+}
+
+#[test]
+fn notes_name_the_held_state_each_mode_applies() {
+    let line = json!({
+        "category": "Bug",
+        "state": "ready-for-agent",
+        "issues": [{"title": "Export", "body": "## Agent Brief"}],
+        "investigation": "Found it."
+    });
+    let notes = |input: &Input| {
+        let mut recommendation = interpret(input, false, line.clone()).unwrap();
+        match recommendation.publishing() {
+            Publishing::Report { issues, .. } => issues[0].notes(),
+            Publishing::Existing { issue, .. } => issue.notes(),
+        }
+    };
+
+    assert_eq!(
+        notes(&report()),
+        "\n\nready-for-agent was recommended; needs-triage is applied until the Day shift permits readiness."
+    );
+    assert_eq!(
+        notes(&existing()),
+        "\n\nready-for-agent was recommended; ready-for-human is applied until the Day shift permits readiness."
+    );
+}
+
+#[test]
+fn notes_carry_a_confirmation_block_or_a_questionnaire() {
+    let input = report();
+    let mut recommendation = interpret(
+        &input,
+        true,
+        json!({
+            "category": "Bug",
+            "state": "ready-for-human",
+            "issues": [
+                {"title": "Blocked", "body": "b", "confirmation_blocked": "needs production access"},
+                {"title": "Ask", "body": "b", "state": "needs-info", "questionnaire": "Which browser?"}
+            ],
+            "investigation": "x"
+        }),
+    )
+    .unwrap();
+
+    let Publishing::Report { issues, .. } = recommendation.publishing() else {
+        panic!("a Report recommendation publishes as a Report");
+    };
+    assert_eq!(
+        issues[0].notes(),
+        "\n\nConfirmation needs the Day shift: needs production access"
+    );
+    assert_eq!(issues[1].notes(), "\n\n## Questionnaire\n\nWhich browser?");
+}