Pre-push review: T-2276/place-extraction

diff --git a/Asterism/Asterism/CharacterExtraction/CharacterExtractionCoordinator.swift b/Asterism/Asterism/CharacterExtraction/CharacterExtractionCoordinator.swiftindex b08295b..4d21d1d 100644--- a/Asterism/Asterism/CharacterExtraction/CharacterExtractionCoordinator.swift+++ b/Asterism/Asterism/CharacterExtraction/CharacterExtractionCoordinator.swift@@ -44,6 +44,16 @@ final class CharacterExtractionCoordinator {     private let lane: ModelLane      private var ledger = CharacterExtractionLedger()+    /// Each work's last candidate read, kept so the review sheet can preview a+    /// reclassification without paying for a second fetch on a toggle (Req 2.2,+    /// design §Review).+    ///+    /// The preview needs the *destination* kind's accepted facts and suppressed+    /// identities, and this is the only read that has them. It is a snapshot,+    /// deliberately: a suppression that synced in since the read affects the+    /// preview and nothing else, because the commit dedups against the store.+    /// Refreshed by every pass over the work and by `reconcile()`.+    private var contexts: [UUID: CharacterExtractionContext] = [:]     /// The attempt is the coordinator's, never the caller's: a view that goes     /// away must not cancel work the ledger has already recorded.     private var attemptTask: Task<SourceOutcome, Never>?@@ -74,6 +84,10 @@ final class CharacterExtractionCoordinator {      var worksWithProposals: Set<UUID> { ledger.worksWithProposals } +    /// The work's last candidate read, or nil when no pass or reconcile has+    /// seen the work in this run. The reclassify preview's input (Req 2.2).+    func context(for work: UUID) -> CharacterExtractionContext? { contexts[work] }+     /// Req 1.11: hidden, not disabled — an action that can never do anything is     /// not an action.     var canRunManualPass: Bool { isModelAvailable }@@ -88,17 +102,50 @@ final class CharacterExtractionCoordinator {      // MARK: - Decisions -    /// Drops the row a committed decision decided. One row per name key per work-    /// (Q83/Q100), so the key identifies it.-    func discard(nameKey: String, for work: UUID) {-        ledger.discard(nameKey: nameKey, for: work)+    /// Drops the row a committed decision decided. One row per proposal key per+    /// work (Q83/Q100), so the key identifies it — the **assembled** kind and+    /// the name key, whichever kind the row was displaying at the time (Q28).+    ///+    /// `nameKeySuppressedKinds` is what the commit **wrote** a name-key+    /// suppression under, and the only field that may be passed here is+    /// `DecisionRequest.nameKeySuppressedKinds` — the gated one, empty for+    /// everything but a candidate skip (Q77). `suppressedKinds` is the ungated+    /// reading and is never empty: sweeping on an *accepted* union row's copy of+    /// it would discard a legitimate same-name row of the other kind that+    /// another source produced, which Req 2.4 forbids.+    ///+    /// Two of them is Q56's case: the reader skipped the name under both kinds,+    /// so a row of that name key held under the other kind — a "Bay — Place"+    /// another source produced — would outlive a suppression that contradicts+    /// it, and it goes too.+    ///+    /// Passing nothing discards the one row, which is what every decision but+    /// that skip does.+    func discard(+        _ key: ProposalKey, for work: UUID, nameKeySuppressedKinds: Set<RecordKind> = []+    ) {+        ledger.discard(key, for: work)+        guard nameKeySuppressedKinds.count > 1 else { return }+        for kind in nameKeySuppressedKinds where kind != key.kind {+            ledger.discard(ProposalKey(kind: kind, nameKey: key.nameKey), for: work)+        }     }      /// Q66/Q110: applies a `.reRouted` refusal's payload to the row it was-    /// about, so the refreshed sheet re-presents it against the character it+    /// about, so the refreshed sheet re-presents it against the record it     /// really resolves onto rather than re-reading the row that just refused.-    func retarget(nameKey: String, for work: UUID, to characterID: UUID?) {-        ledger.retarget(nameKey: nameKey, for: work, to: characterID)+    func retarget(_ key: ProposalKey, for work: UUID, to recordID: UUID?) {+        ledger.retarget(key, for: work, to: recordID)+    }++    /// Req 2.2: the reader changed a row's kind, and the sheet has previewed+    /// what that kind resolves onto (Q24). Both go onto the held row, so the+    /// choice survives the sheet being closed and reopened within the app run,+    /// and a later settlement's merge keeps it (Q28, Q69).+    func reclassify(+        _ key: ProposalKey, for work: UUID, to kind: RecordKind, target: UUID?+    ) {+        ledger.reclassify(key, for: work, to: kind, target: target)     }      // MARK: - The activation sweep (Req 1.1, 1.2)@@ -140,9 +187,9 @@ final class CharacterExtractionCoordinator {             return         } -        let candidates: [CharacterExtractionCandidate]+        let candidates: [ExtractionCandidate]         do {-            candidates = try await library.characterExtractionCandidates(+            candidates = try await library.extractionCandidates(                 limit: CharacterExtractionBounds.worksExamined, workIDs: nil)         } catch {             // A library that is not ready yet skips this activation in silence@@ -187,9 +234,9 @@ final class CharacterExtractionCoordinator {     func reconcile() async {         let tracked = ledger.trackedWorks         guard !tracked.isEmpty else { return }-        let rows: [CharacterExtractionCandidate]+        let rows: [ExtractionCandidate]         do {-            rows = try await library.characterExtractionCandidates(+            rows = try await library.extractionCandidates(                 limit: tracked.count, workIDs: tracked)         } catch {             CharacterExtractionLog.failure(@@ -200,10 +247,20 @@ final class CharacterExtractionCoordinator {         for row in rows {             states[row.workID] = WorkExtractionState(                 revisions: row.revisionsBySource,-                characterIDs: Set(row.characters.map(\.id)))+                recordIDs: Dictionary(+                    uniqueKeysWithValues: RecordKind.allCases.map {+                        ($0, Set(row.records(of: $0).map(\.id)))+                    }))+            // The newest read of a tracked work is the one a reclassify preview+            // should be run against (Req 2.2).+            contexts[row.workID] = CharacterExtractionContext(row)         }+        // A work the read no longer offers is gone or torn; its rows go below,+        // and its retained read goes with them.+        for work in tracked where states[work] == nil { contexts[work] = nil }          let invalidated = ledger.reconcile(against: states)+        pruneContexts()         if !invalidated.isEmpty {             CharacterExtractionLog.note("reconcile invalidated \(invalidated.count) work(s)")             // A voided attempt's answer is discarded whatever it says; cancelling@@ -212,6 +269,19 @@ final class CharacterExtractionCoordinator {         }     } +    /// The retained reads, bounded by the ledger rather than by nothing.+    ///+    /// `contexts` used to be cleared only for a *tracked* work the library no+    /// longer offers and by a memory warning, so a work the sweep processed that+    /// produced no proposals kept its read for the life of the session. The+    /// ledger already answers which works are still live — anything held,+    /// attempted or in flight — so that is the bound, stated once here and+    /// applied after the two places that add to the dictionary.+    private func pruneContexts() {+        let tracked = ledger.trackedWorks+        contexts = contexts.filter { tracked.contains($0.key) }+    }+     /// Req 1.2: the sweep stops with the foreground, and its attempt with it. A     /// manual pass is the reader's and continues.     func resignActive() {@@ -221,6 +291,8 @@ final class CharacterExtractionCoordinator {     /// Held proposals are re-derivable — their revisions are not covered — so     /// they are the first thing to go under memory pressure (Q61).     func memoryWarning() {+        // The retained reads go with the rows they were kept to preview.+        contexts.removeAll()         if ledger.memoryWarning() != nil { attemptTask?.cancel() }     } @@ -237,10 +309,10 @@ final class CharacterExtractionCoordinator {         }         manualOutcomes[workID] = .running -        let candidate: CharacterExtractionCandidate?+        let candidate: ExtractionCandidate?         do {             candidate = try await library-                .characterExtractionCandidates(limit: 1, workIDs: [workID]).first+                .extractionCandidates(limit: 1, workIDs: [workID]).first         } catch {             CharacterExtractionLog.failure(                 "\(workID): manual pass — candidate read failed: \(CharacterExtractionLog.describe(error))")@@ -269,13 +341,14 @@ final class CharacterExtractionCoordinator {     /// `sweep` is the generation of the sweep this pass belongs to, and nil for     /// the reader's own pass, which no stop signal ends (Req 1.11).     private func process(-        _ candidate: CharacterExtractionCandidate, pass: ExtractionPassKind,+        _ candidate: ExtractionCandidate, pass: ExtractionPassKind,         sweep generation: Int? = nil     ) async {         let context = CharacterExtractionContext(candidate)+        contexts[candidate.workID] = context         let revisions = candidate.revisionsBySource         let sources = candidate.extractionSources(includingCovered: pass == .manual)-        var covered: [CharacterCompletedSource] = []+        var covered: [CompletedSource] = []          for source in sources {             // Q110: the stop signal is checked **per source**, not per work. A@@ -298,13 +371,15 @@ final class CharacterExtractionCoordinator {                 source, context: context, revisions: revisions, pass: pass)             if outcome == .producedNone {                 covered.append(-                    CharacterCompletedSource(ref: source.source, fingerprint: source.fingerprint))+                    CompletedSource(ref: source.source, fingerprint: source.fingerprint))             }         } +        pruneContexts()+         guard !covered.isEmpty else { return }         do {-            let written = try await library.advanceCharacterCoverage(+            let written = try await library.advanceCoverage(                 workID: candidate.workID, sources: covered)             CharacterExtractionLog.note(                 "\(candidate.workID): produced-none covered \(written) of \(covered.count) source(s)")@@ -457,13 +532,19 @@ final class CharacterExtractionCoordinator {      private var currentEnvironment: ModelWorkEnvironment { environment.modelWorkEnvironment } +    /// Design §Diagnostics: a settle line names the kind, so one filtered+    /// Console session says which half of the combined answer survived.     private static func describe(_ settlement: ExtractionSettlement) -> String {         switch settlement {         case .proposals(let proposals):-            proposals.isEmpty ? "no proposals" : "\(proposals.count) proposal(s)"-        case .failed: "failed"-        case .timedOut: "timed out"-        case .cancelled: "cancelled"+            guard !proposals.isEmpty else { return "no proposals" }+            let byKind = RecordKind.allCases+                .map { kind in "\(proposals.count { $0.kind == kind }) \(kind.rawValue)" }+                .joined(separator: ", ")+            return "\(proposals.count) proposal(s) (\(byKind))"+        case .failed: return "failed"+        case .timedOut: return "timed out"+        case .cancelled: return "cancelled"         }     } 

diff --git a/Asterism/Asterism/CharacterExtraction/CharacterExtractor.swift b/Asterism/Asterism/CharacterExtraction/CharacterExtractor.swiftindex 92252f2..dcf491e 100644--- a/Asterism/Asterism/CharacterExtraction/CharacterExtractor.swift+++ b/Asterism/Asterism/CharacterExtraction/CharacterExtractor.swift@@ -54,7 +54,8 @@ actor CharacterExtractor {         let grounded = CharacterGrounding.ground(result, from: source)         for drop in grounded.drops {             CharacterExtractionLog.note(-                "\(CharacterExtractionLog.describe(source.source)): dropped a candidate — \(drop.reason.rawValue)",+                "\(CharacterExtractionLog.describe(source.source)): dropped a \(drop.kind.rawValue) "+                    + "candidate — \(drop.reason.rawValue)",                 content: "name=\"\(drop.name)\"")         }         return (grounded.candidates, started.duration(to: .now))

diff --git a/Asterism/Asterism/CharacterExtraction/CharacterReviewModel.swift b/Asterism/Asterism/CharacterExtraction/CharacterReviewModel.swiftindex 9112273..6a04c85 100644--- a/Asterism/Asterism/CharacterExtraction/CharacterReviewModel.swift+++ b/Asterism/Asterism/CharacterExtraction/CharacterReviewModel.swift@@ -5,7 +5,8 @@ import Foundation // the default; the log body itself is `CharacterExtractionLog`'s. import OSLog -// The review list (Reqs 2.1, 2.2, 2.5, 2.7, 2.8).+// The review list (`character-extraction` Reqs 2.1, 2.2, 2.5, 2.7, 2.8;+// `place-extraction` Reqs 2.1–2.3). // // Modelled on `PostTeachingWorkURLModel`'s queue: a list of independent // decisions, each committed on its own, each failure keeping its own row and@@ -17,6 +18,11 @@ import OSLog // on the next open. The single in-place refresh is the commit-refusal // disclosure, which is the case where what the reader is looking at is known to // be wrong.+//+// One list holds both kinds. A row's *identity* is the kind the pass assembled+// it under and its name key (Q28); the kind it is **displayed** under moves when+// the reader reclassifies it, and everything the decision carries is read off+// the projection that move produces (Q59).  /// One proposed alias on a row, and whether the reader has struck it (Q92). struct CharacterReviewAlias: Identifiable, Equatable, Sendable {@@ -33,34 +39,77 @@ struct CharacterReviewFact: Identifiable, Equatable, Sendable {     let quote: String     let source: SourceRef     var isTicked: Bool-    let fact: CharacterFact+    let fact: RecordFact }  /// One row of the review list: a new candidate, or a bundle of additional-/// content for a character the work already has.+/// content for a record the work already has. struct CharacterReviewRow: Identifiable, Equatable, Sendable {-    /// The proposal's name key. One row per key per work (Q83/Q100), so the key-    /// identifies the row for every decision that follows.+    /// The proposal key's string form. One row per key per work (Q83/Q100), so+    /// the key identifies the row for every decision that follows — and two+    /// rows of one name key under two kinds are two rows (Q28).     let id: String+    /// The same identity as the coordinator holds it under.+    let key: ProposalKey     let name: String+    /// The kind the row is **displayed** and decided under (Req 2.2).+    let kind: RecordKind+    /// The kind the pass assembled it under — what its identity is made of, and+    /// what a toggle is measured against.+    let originalKind: RecordKind     let isBundle: Bool-    /// The character a bundle enriches, for the existing facts it is shown+    /// Req 2.2: candidates, and the bundles a reclassification produced. A+    /// bundle the pass itself assembled has an existing record on the other end+    /// and is not the reader's to re-file.+    let canReclassify: Bool+    /// Req 1.5's union row: the model returned this name under both kinds, and a+    /// skip decides both (Q23/Q38).+    let isDualKind: Bool+    /// Q41: the *other* kind already holds a record of this name. Presentation+    /// only — matching never crosses kinds (Q13).+    let crossKindHint: String?+    /// The record a bundle enriches, for the existing facts it is shown     /// beside (Q38).     let targetID: UUID?     var aliases: [CharacterReviewAlias]     var proposedFacts: [CharacterReviewFact]-    /// The target character's facts as they stand, so the reader can see what-    /// the bundle adds to (Req 2.1). Empty for a candidate.-    let existingFacts: [WorkCharacterFactRow]-    /// The held proposal this row was built from, so the decision request is-    /// assembled from the pipeline's own seam rather than re-derived here.+    /// The target record's facts as they stand, so the reader can see what the+    /// bundle adds to (Req 2.1). Empty for a candidate.+    let existingFacts: [WorkRecordFactRow]+    /// The held proposal this row was built from — its identity, and the basis+    /// every preview is computed from, so toggling back and forth neither loses+    /// facts nor compounds a re-key.     let proposal: ExtractionProposal+    /// The proposal as the displayed kind leaves it: facts re-keyed to the+    /// previewed target and re-deduped under that kind, aliases and cited+    /// revisions unchanged. **The decision request is built from this**, never+    /// from `proposal` (Q59).+    let projected: ExtractionProposal      var struckAliases: Set<String> { Set(aliases.filter(\.isStruck).map(\.name)) } -    var untickedFacts: Set<CharacterFactIdentity> {+    var untickedFacts: Set<RecordFactIdentity> {         Set(proposedFacts.filter { !$0.isTicked }.map(\.fact.identity))     }++    /// Req 2.2: a reclassified row whose facts all deduped away under the+    /// destination has nothing left to keep. It stays displayed, with the kind+    /// control and with skip as the decision it can still take (Q31).+    ///+    /// A candidate the model returned with **no** facts at all is not that row:+    /// Req 1.2 admits one, and it is the common shape for a place named in+    /// passing. Nothing deduped away, so the name — which is what the reader+    /// wanted when they re-filed it — is still there to keep, and leaving Skip+    /// as the only decision would suppress it.+    ///+    /// An **unstruck alias** counts as content worth keeping too, on Q36's+    /// survival predicate: a reclassified row whose facts all deduped away but+    /// which still offers the destination a name it does not have is a real+    /// addition, and disabling Keep on it threw that alias away.+    var canAccept: Bool {+        kind == originalKind || !proposedFacts.isEmpty || proposal.facts.isEmpty+            || aliases.contains { !$0.isStruck }+    } }  @MainActor @Observable@@ -83,26 +132,36 @@ final class CharacterReviewModel: Identifiable {     var isEmpty: Bool { rows.isEmpty }      private let workID: UUID-    private var characters: [WorkCharacterPresentation]-    /// Q88's display order needs the notes' capture order, and a *proposed* fact-    /// has no `WorkCharacterPresentation` to have been ordered inside. Without-    /// it a merged row's facts came out in entry-UUID order — the pipeline's-    /// canonical order (Q75) — and contradicted the work page showing the same-    /// facts once they were kept.-    private var captureOrder: [UUID: Int]+    /// Everything a row is drawn and previewed against: both kinds'+    /// presentations, the notes' capture order, and the suppressions the+    /// coordinator's last candidate read left standing.+    private var inputs: ReviewInputs     private let library: any LibraryProviding-    /// Told which row was decided, so the coordinator can drop it from what it-    /// holds.-    private let onDecision: @MainActor (String) -> Void+    /// Told which row was decided and which kinds the commit wrote a name-key+    /// suppression under, so the coordinator can drop it — and, for Q56's+    /// both-kinds skip, the row of the same name key it contradicts.+    ///+    /// The second argument is `DecisionRequest.nameKeySuppressedKinds`, the+    /// gated reading (Q77): `suppressedKinds` is never empty and sweeping on it+    /// would discard a legitimate same-name row after an *accept*.+    private let onDecision: @MainActor (ProposalKey, Set<RecordKind>) -> Void     /// Q66: where a `.reRouted` refusal's payload goes. The coordinator-    /// re-points the held row at the character the commit resolved onto, and+    /// re-points the held row at the record the commit resolved onto, and     /// only then is `refresh` worth re-reading.-    private let onReRoute: @MainActor (String, UUID?) -> Void+    private let onReRoute: @MainActor (ProposalKey, UUID?) -> Void+    /// Req 2.2/Q28: the reader's kind and the target the preview resolved, so+    /// the held row remembers both — the choice survives the sheet closing, and+    /// a later settlement's merge keeps it (Q69).+    private let onReclassify: @MainActor (ProposalKey, RecordKind, UUID?) -> Void     /// The coordinator's held rows, for the one refresh Req 2.7 allows —     /// **after** it has reconciled them (Q110). Async because that reconcile is     /// a library read: the stale disclosure claims the list below is up to date,     /// and the invalidation pass is the only thing that can make it so.     private let refresh: @MainActor () async -> [ExtractionProposal]+    /// The work's last candidate read, as the coordinator retains it. The+    /// reclassify preview's suppression input (Req 2.2), and nil before any+    /// pass has seen the work in this run.+    private let extractionContext: @MainActor () -> CharacterExtractionContext?     /// Whether a row's decision is being committed. One flag for the sheet —     /// decisions commit one save each and the guard in `decide` serialises     /// them — but observable, so the rows show a disabled state instead of the@@ -112,24 +171,30 @@ final class CharacterReviewModel: Identifiable {     init(         workID: UUID,         proposals: [ExtractionProposal],-        characters: [WorkCharacterPresentation],+        characters: [WorkRecordPresentation],+        places: [WorkRecordPresentation] = [],         captureOrder: [UUID: Int] = [:],         library: any LibraryProviding,-        onDecision: @escaping @MainActor (String) -> Void,-        onReRoute: @escaping @MainActor (String, UUID?) -> Void,+        extractionContext: @escaping @MainActor () -> CharacterExtractionContext?,+        onDecision: @escaping @MainActor (ProposalKey, Set<RecordKind>) -> Void,+        onReRoute: @escaping @MainActor (ProposalKey, UUID?) -> Void,+        onReclassify: @escaping @MainActor (ProposalKey, RecordKind, UUID?) -> Void,         refresh: @escaping @MainActor () async -> [ExtractionProposal]     ) {         self.workID = workID-        self.characters = characters-        self.captureOrder = captureOrder+        self.inputs = ReviewInputs(+            characters: characters, places: places, captureOrder: captureOrder,+            suppressedFacts: extractionContext()?.suppressedFacts ?? [:])         self.library = library+        self.extractionContext = extractionContext         self.onDecision = onDecision         self.onReRoute = onReRoute+        self.onReclassify = onReclassify         self.refresh = refresh         // Snapshot at open (Req 2.7).-        self.rows = proposals.map {-            Self.row(from: $0, characters: characters, captureOrder: captureOrder)-        }+        let inputs = self.inputs+        self.rows = proposals.map { Self.row(from: $0, inputs: inputs) }+        syncPreviewedTargets()     }      // MARK: - Reader input@@ -150,6 +215,38 @@ final class CharacterReviewModel: Identifiable {         rows[rowIndex].aliases[aliasIndex].isStruck = isStruck     } +    /// Req 2.2: the reader re-files a candidate under the other kind, and the+    /// row is redrawn **at once** against that kind (Q24) — as a bundle where+    /// the name resolves onto a record the work already has, as a candidate+    /// where it does not.+    ///+    /// The row never leaves the list, whatever the preview finds (Q31), and the+    /// reader's ticks and strikes come with it: a tick is keyed by display row+    /// id, which excludes the name key precisely so a re-keyed fact keeps it+    /// (Q59 — the identity triple would not, which is why the request is built+    /// from the projection rather than matched by identity against the held+    /// row).+    func reclassify(_ rowID: String, to kind: RecordKind) {+        guard let rowIndex = rows.firstIndex(where: { $0.id == rowID }) else { return }+        let row = rows[rowIndex]+        // Idempotent for the kind already displayed: re-deriving it would be a+        // no-op that still rewrote the reader's ticks.+        guard row.canReclassify, row.kind != kind else { return }++        var rebuilt = Self.row(from: row.proposal, displayedAs: kind, inputs: inputs)+        let ticks = Dictionary(+            row.proposedFacts.map { ($0.id, $0.isTicked) }, uniquingKeysWith: { first, _ in first })+        for index in rebuilt.proposedFacts.indices {+            rebuilt.proposedFacts[index].isTicked = ticks[rebuilt.proposedFacts[index].id] ?? true+        }+        let strikes = row.struckAliases+        for index in rebuilt.aliases.indices {+            rebuilt.aliases[index].isStruck = strikes.contains(rebuilt.aliases[index].name)+        }+        rows[rowIndex] = rebuilt+        onReclassify(row.key, kind, rebuilt.targetID)+    }+     /// Dismissing leaves undecided rows exactly where they are (Req 2.6): the     /// coordinator still holds them, and the next open re-presents them.     func dismiss() {@@ -163,39 +260,43 @@ final class CharacterReviewModel: Identifiable {      func skip(_ rowID: String) async { await decide(rowID, action: .skip) } -    private func decide(_ rowID: String, action: CharacterDecisionAction) async {+    private func decide(_ rowID: String, action: DecisionAction) async {         guard !isSubmitting, let row = rows.first(where: { $0.id == rowID }) else { return }         isSubmitting = true         defer { isSubmitting = false }         disclosure = nil         routesToCheckLibrary = false -        let request = row.proposal.decisionRequest(+        // Q59: from the **projection**. Building it from the held row would send+        // a place decision the character kind's fact set.+        let request = row.projected.decisionRequest(             workID: workID, action: action,             struckAliases: row.struckAliases, untickedFacts: row.untickedFacts) -        let outcome: CharacterDecisionOutcome+        let outcome: DecisionOutcome         do {-            outcome = try await library.commitCharacterDecision(request)+            outcome = try await library.commitDecision(request)         } catch {             disclosure = "That could not be saved. Try again."             CharacterExtractionLog.failure(-                "character decision failed — \(CharacterExtractionLog.describe(error))")+                "\(row.kind.rawValue) decision failed — \(CharacterExtractionLog.describe(error))")             return         }          switch outcome {         case .committed:             rows.removeAll { $0.id == rowID }-            onDecision(rowID)+            // Q56/Q77: the gated field, so only a candidate skip can sweep the+            // other kind's row of this name key away with it.+            onDecision(row.key, request.nameKeySuppressedKinds)         case .refused(let refusal):-            await handle(refusal, rowID: rowID, action: action)+            await handle(refusal, row: row, action: action)         }     }      /// Req 2.7/2.8's disclosures, and the one in-place refresh the sheet does.     private func handle(-        _ refusal: CharacterDecisionRefusal, rowID: String, action: CharacterDecisionAction+        _ refusal: DecisionRefusal, row: CharacterReviewRow, action: DecisionAction     ) async {         switch refusal {         case .staleSource:@@ -207,53 +308,57 @@ final class CharacterReviewModel: Identifiable {             // the same row and earned the same refusal on the next Keep.             await refreshRows()         case .reRouted(let target):-            disclosure = "This turned out to belong to a character you already have, "-                + "so nothing was saved. It is shown against them now."+            disclosure = RecordKindPresentation.reRouteDisclosure(row.kind)             // Q66: the refusal carries where the row actually resolves, and             // applying it before the re-read is what makes the re-presentation             // real. Without it the reader looped Keep → refuse → Keep.-            onReRoute(rowID, target)+            onReRoute(row.key, target)             await refreshRows()-        case .torn(let characterID):-            disclosure = characterID == nil-                ? "This work exists in differing copies, so nothing can be added to it yet. "-                    + "Open Check Library to choose which copy to keep."-                : "That character exists in differing copies, so nothing can be added to them "-                    + "yet. Open Check Library to choose which copy to keep."+        case .torn(let recordID):+            disclosure = tornDisclosure(recordID: recordID, kind: row.kind)             routesToCheckLibrary = true         case .workGone:             disclosure = nil             rows = []-            onDecision(rowID)+            onDecision(row.key, [])         }         CharacterExtractionLog.note(-            "character \(action.rawValue) refused — \(String(describing: refusal))",+            "\(row.kind.rawValue) \(action.rawValue) refused — \(String(describing: refusal))",             level: .info)     } +    private func tornDisclosure(recordID: UUID?, kind: RecordKind) -> String {+        guard recordID != nil else {+            return "This work exists in differing copies, so nothing can be added to it yet. "+                + "Open Check Library to choose which copy to keep."+        }+        return RecordKindPresentation.tornRecordDisclosure(kind)+    }+     /// The refreshed list, re-presented from what the coordinator now holds — so     /// a candidate that has become a bundle is shown as one and the reader is     /// not looped through the same refusal.     ///     /// **Both** halves are re-read (Q110). The coordinator reconciles before it-    /// answers, and the work's characters come back with the rows: the character-    /// a re-route resolved onto may have been created seconds ago by a sibling+    /// answers, and the work's records come back with the rows: the record a+    /// re-route resolved onto may have been created seconds ago by a sibling     /// accept in this very sheet, and a bundle drawn against the open-time     /// snapshot would be shown under the model's spelling with no existing facts     /// beside it.     private func refreshRows() async {         let held = await refresh()         if let detail = try? await library.workDetail(id: workID) {-            characters = detail.characters-            captureOrder = detail.captureOrder+            inputs.setRecords(characters: detail.characters, places: detail.places)+            inputs.captureOrder = detail.captureOrder         } else {             // A failed read leaves the previous snapshot standing: an empty-            // character list would redraw every bundle as if its target held+            // record list would redraw every bundle as if its target held             // nothing, which is a worse answer than a slightly old one.             CharacterExtractionLog.failure(-                "character review refresh could not re-read the work's characters")+                "character review refresh could not re-read the work's records")         }-        // Both kept per row, not per value: one row per name key per work+        inputs.suppressedFacts = extractionContext()?.suppressedFacts ?? [:]+        // Both kept per row, not per value: one row per proposal key per work         // (Q83/Q100), and two rows proposing the same alias string — or the same         // fact — are two decisions. Keyed globally, one row's strike travelled to         // the other's on every refresh.@@ -270,9 +375,9 @@ final class CharacterReviewModel: Identifiable {             uniquingKeysWith: { first, _ in first })         let strikes = Dictionary(             rows.map { ($0.id, $0.struckAliases) }, uniquingKeysWith: { first, _ in first })+        let inputs = self.inputs         rows = held.map { proposal in-            var row = Self.row(-                from: proposal, characters: characters, captureOrder: captureOrder)+            var row = Self.row(from: proposal, inputs: inputs)             for index in row.proposedFacts.indices {                 // The reader's ticks survive the refresh: they decided those,                 // and the refusal was about the store, not about them.@@ -285,22 +390,186 @@ final class CharacterReviewModel: Identifiable {             }             return row         }+        syncPreviewedTargets()+    }++    /// Q69: the ledger's merge keeps a reclassified row's `displayedKind` and+    /// the **older** row's previewed target, because a pure value type has no+    /// presentations to preview against. This is where that target is replaced:+    /// the row above was re-previewed over the merged content, and the held row+    /// is told, so the next reconcile judges it against the record the reader is+    /// actually looking at rather than one resolved against an earlier read.+    private func syncPreviewedTargets() {+        for row in rows+        where row.kind != row.originalKind && row.projected.target != row.proposal.target {+            onReclassify(row.key, row.kind, row.targetID)+        }     }      // MARK: - Row construction +    /// Both kinds' presentations and the standing suppressions, as the row+    /// builder needs them. One value rather than four parameters, because a+    /// preview asks all four of them per kind.+    private struct ReviewInputs {+        private(set) var characters: [WorkRecordPresentation]+        private(set) var places: [WorkRecordPresentation]+        var captureOrder: [UUID: Int]+        var suppressedFacts: [RecordKind: Set<RecordFactIdentity>]++        /// The two reductions of a kind's presentations every row asks for,+        /// computed when the presentations are **set** rather than per row.+        /// Building a row matches twice (its own kind and the cross-kind hint)+        /// and dedupes against the accepted facts once, so a sheet of N rows+        /// re-derived both of these 3N times from one unchanged snapshot.+        private var derived: [RecordKind: Derived]++        private struct Derived {+            let targets: [MatchTarget]+            let acceptedFacts: Set<RecordFactIdentity>++            init(_ records: [WorkRecordPresentation]) {+                targets = records.map(ReviewInputs.matchTarget)+                // Accepted identities come from the presentations: the+                // destination's own facts are what a re-keyed proposal fact+                // dedups against (Req 1.6).+                acceptedFacts = Set(records.flatMap(\.facts).map(\.fact.identity))+            }+        }++        init(+            characters: [WorkRecordPresentation] = [],+            places: [WorkRecordPresentation] = [],+            captureOrder: [UUID: Int] = [:],+            suppressedFacts: [RecordKind: Set<RecordFactIdentity>] = [:]+        ) {+            self.characters = characters+            self.places = places+            self.captureOrder = captureOrder+            self.suppressedFacts = suppressedFacts+            derived = [.character: Derived(characters), .place: Derived(places)]+        }++        /// The one way the presentations move, so the derivations cannot be+        /// left behind by an assignment that forgot them.+        mutating func setRecords(+            characters: [WorkRecordPresentation], places: [WorkRecordPresentation]+        ) {+            self = ReviewInputs(+                characters: characters, places: places, captureOrder: captureOrder,+                suppressedFacts: suppressedFacts)+        }++        func records(of kind: RecordKind) -> [WorkRecordPresentation] {+            switch kind {+            case .character: characters+            case .place: places+            }+        }++        /// Req 2.3's tiers, run over one kind's presentations —+        /// `RecordMatching` itself, because the commit re-runs the same tiers+        /// against the store and the two answers have to be one answer.+        func match(_ nameKey: String, of kind: RecordKind) -> WorkRecordPresentation? {+            guard let target = RecordMatching.match(+                nameKey: nameKey, among: derived[kind]?.targets ?? [])+            else { return nil }+            return records(of: kind).first { $0.id == target.id }+        }++        /// Tornness is not a matching input — the commit gate owns it (Req 2.8)+        /// — but it is carried so the target reads the same either side.+        static func matchTarget(_ record: WorkRecordPresentation) -> MatchTarget {+            MatchTarget(+                id: record.id,+                currentNameKey: RecordNameKey.normalize(record.name),+                retainedKey: record.nameKey,+                aliasKeys: record.aliases.map(RecordNameKey.normalize),+                isTorn: record.isTorn)+        }++        /// Accepted identities come from the presentations: the destination's+        /// own facts are what a re-keyed proposal fact dedups against (Req 1.6).+        func acceptedFacts(of kind: RecordKind) -> Set<RecordFactIdentity> {+            derived[kind]?.acceptedFacts ?? []+        }++        /// Suppressed identities come from the coordinator's retained read. A+        /// stale index affects the preview and nothing else: the commit dedups+        /// against the store, and accepting a ticked fact clears its+        /// suppression (Req 2.4).+        func suppressedFacts(of kind: RecordKind) -> Set<RecordFactIdentity> {+            suppressedFacts[kind] ?? []+        }+    }++    /// The proposal as `kind` leaves it (Q59): the target that kind's records+    /// resolve, and the facts re-keyed to it and re-deduped under it.+    ///+    /// Aliases and cited revisions are untouched — an alias is the reader's to+    /// strike and a revision is what staleness is judged against, and neither is+    /// a statement about the kind.+    private static func project(+        _ proposal: ExtractionProposal, to kind: RecordKind, inputs: ReviewInputs+    ) -> ExtractionProposal {+        let target = inputs.match(proposal.nameKey, of: kind)+        let resolvedKey = target?.nameKey ?? proposal.nameKey+        let accepted = inputs.acceptedFacts(of: kind)+        let suppressed = inputs.suppressedFacts(of: kind)++        var facts: [GroundedFact] = []+        var seen: Set<RecordFactIdentity> = []+        for fact in proposal.facts {+            let keyed = fact.keyed(to: resolvedKey)+            guard seen.insert(keyed.identity).inserted else { continue }+            guard !accepted.contains(keyed.identity), !suppressed.contains(keyed.identity) else {+                continue+            }+            facts.append(keyed)+        }++        var projected = proposal+        projected.displayedKind = kind+        projected.target = target.map { .existing($0.id) } ?? .newRecord+        projected.facts = facts+        return projected+    }+     private static func row(-        from proposal: ExtractionProposal, characters: [WorkCharacterPresentation],-        captureOrder: [UUID: Int]+        from proposal: ExtractionProposal, displayedAs displayedKind: RecordKind? = nil,+        inputs: ReviewInputs     ) -> CharacterReviewRow {-        let targetID: UUID? = if case .existing(let id) = proposal.target { id } else { nil }-        let target = targetID.flatMap { id in characters.first { $0.id == id } }+        let displayed = displayedKind ?? proposal.displayedKind+        // A row nobody has reclassified is shown exactly as the pass assembled+        // it: the assembler resolved it against the store under a lock, and+        // re-previewing it here would answer the same question from a snapshot.+        // Once a kind has moved, the held target was written by a preview and+        // only a preview can move it back — including a merged row's, which the+        // ledger carried over from the older row (Q69).+        let isPristine = proposal.displayedKind == proposal.kind+        let projected = isPristine && displayed == proposal.kind+            ? proposal+            : project(proposal, to: displayed, inputs: inputs)++        let targetID: UUID? = if case .existing(let id) = projected.target { id } else { nil }+        let target = targetID.flatMap { id in inputs.records(of: displayed).first { $0.id == id } }+        let captureOrder = inputs.captureOrder+         return CharacterReviewRow(-            id: proposal.nameKey,-            // A bundle is shown under the character's own name, not the model's+            id: proposal.key.rowID,+            key: proposal.key,+            // A bundle is shown under the record's own name, not the model's             // spelling of it: the reader knows them by what they called them.             name: target?.name ?? proposal.name,-            isBundle: proposal.isBundle,+            kind: displayed,+            originalKind: proposal.kind,+            isBundle: projected.isBundle,+            // Req 2.2: a candidate always, a bundle only where a+            // reclassification produced it — which is exactly where the+            // displayed kind has moved off the assembled one.+            canReclassify: !proposal.isBundle || displayed != proposal.kind,+            isDualKind: proposal.isDualKind,+            crossKindHint: hint(for: proposal.nameKey, displayedAs: displayed, inputs: inputs),             targetID: targetID,             aliases: proposal.proposedAliases.map {                 CharacterReviewAlias(name: $0, isStruck: false)@@ -308,9 +577,9 @@ final class CharacterReviewModel: Identifiable {             // Q88/AC 2.1's display order, applied here rather than upstream: the             // pipeline's own order is Q75's canonical one (entries by UUID),             // which is right for merging and encoding and wrong on screen. The-            // reader reads a character's facts as history, and the work page-            // shows exactly this order once they are kept.-            proposedFacts: proposal.facts+            // reader reads a record's facts as history, and the work page shows+            // exactly this order once they are kept.+            proposedFacts: projected.facts                 .map { fact in                     let stored = fact.storedFact                     return CharacterReviewFact(@@ -326,6 +595,19 @@ final class CharacterReviewModel: Identifiable {                     return left.statement < right.statement                 },             existingFacts: target?.facts ?? [],-            proposal: proposal)+            proposal: proposal,+            projected: projected)+    }++    /// Q41: the model files places as characters often enough that the reader's+    /// one-tap correction needs a reason to be offered. The hint says the other+    /// kind already answers to this name; it changes no matching and commits+    /// nothing.+    private static func hint(+        for nameKey: String, displayedAs kind: RecordKind, inputs: ReviewInputs+    ) -> String? {+        let other = kind.other+        guard inputs.match(nameKey, of: other) != nil else { return nil }+        return RecordKindPresentation.existingNameHint(other)     } }

diff --git a/Asterism/Asterism/UITestLaunchSupport.swift b/Asterism/Asterism/UITestLaunchSupport.swiftindex 8ee2b5f..9ddaf4b 100644--- a/Asterism/Asterism/UITestLaunchSupport.swift+++ b/Asterism/Asterism/UITestLaunchSupport.swift@@ -180,33 +180,82 @@ enum UITestLaunchSupport {     static let extractionKey = "ASTERISM_UI_TEST_EXTRACTION"      #if DEBUG || ASTERISM_PERFORMANCE_TESTING-    /// The characters the canned client proposes. They ground against the-    /// `seeded-characters` fixture's generic notes, so what the reader sees is-    /// the real grounding and assembly over a scripted model answer rather than-    /// a hand-built proposal list.+    /// The characters and places the canned client proposes. They ground+    /// against the `seeded-characters` fixture's generic notes, so what the+    /// reader sees is the real grounding and assembly over a scripted model+    /// answer rather than a hand-built proposal list.+    ///+    /// Three shapes the place journey needs, all of them assembled rather than+    /// asserted here:+    ///+    /// - **Kestrel Head** is a place and nothing else: its quote sits verbatim+    ///   in the fixture's notes and its name is capitalised there, so it passes+    ///   grounding's capital-letter rule (Q42) and lands in the Places section.+    /// - **Selkie** is returned under *both* kinds with no existing record of+    ///   either, which is Req 1.5's union row: one row, displayed as a+    ///   character (Q20), carrying both copies' facts and disclosing that a+    ///   skip decides both (Q38).+    /// - **Ada/Nightjar** and **Brede** are the character-only rows the+    ///   pre-place journey already ran over, unchanged.     ///     /// Inside the guard with its only consumer: a release build has no scripted     /// client to hand it to, and a fixture compiled into the shipping binary is     /// dead weight that reads as production data.-    static let cannedExtractionResult = ExtractionResult(characters: [-        ExtractedCharacter(-            name: "Ada/Nightjar",-            facts: [-                ExtractedFact(-                    statement: "Ada keeps the lighthouse.",-                    quote: "Ada keeps the lighthouse"),-                ExtractedFact(-                    statement: "Ada is called Nightjar by the crew.",-                    quote: "the crew call her Nightjar"),-            ]),-        ExtractedCharacter(-            name: "Brede",-            facts: [-                ExtractedFact(-                    statement: "Brede rows the tender.",-                    quote: "Brede rows the tender")-            ]),-    ])+    static let cannedExtractionResult = ExtractionResult(+        characters: [+            ExtractedCharacter(+                name: "Ada/Nightjar",+                facts: [+                    ExtractedFact(+                        statement: "Ada keeps the lighthouse.",+                        quote: "Ada keeps the lighthouse"),+                    ExtractedFact(+                        statement: "Ada is called Nightjar by the crew.",+                        quote: "the crew call her Nightjar"),+                ]),+            ExtractedCharacter(+                name: "Brede",+                facts: [+                    ExtractedFact(+                        statement: "Brede rows the tender.",+                        quote: "Brede rows the tender")+                ]),+            ExtractedCharacter(+                name: "Selkie",+                facts: [+                    ExtractedFact(+                        statement: "Selkie is moored below the light.",+                        quote: "Selkie is moored below")+                ]),+        ],+        places: [+            ExtractedPlace(+                name: "Kestrel Head",+                facts: [+                    ExtractedPlaceFact(+                        statement: "The lighthouse stands at Kestrel Head.",+                        quote: "the lighthouse at Kestrel Head"),+                    // Grounds in the **chapter note** rather than the work's+                    // generic notes, so the kept place holds one fact with a+                    // live citation — which is the only way the entry detail's+                    // Places section (Req 4.4) has anything to draw.+                    ExtractedPlaceFact(+                        statement: "The tender passes Kestrel Head.",+                        quote: "past Kestrel Head"),+                ]),+            ExtractedPlace(+                name: "Selkie",+                facts: [+                    // Deliberately *not* the character copy's wording: the union+                    // row shows both copies' facts, and two identical lines+                    // would read as a display bug rather than as one name the+                    // model filed under both kinds. The quote is the fixture's+                    // text and stays verbatim.+                    ExtractedPlaceFact(+                        statement: "Selkie's mooring lies below the light.",+                        quote: "moored below the light")+                ]),+        ])      static func characterExtractionClient(         environmentProvider: any ProcessEnvironmentProviding = SystemProcessEnvironment()@@ -215,7 +264,9 @@ enum UITestLaunchSupport {         case "canned":             return StubCharacterExtractionModelClient(result: cannedExtractionResult)         case "empty":-            return StubCharacterExtractionModelClient(result: ExtractionResult(characters: []))+            // Both arrays empty: the source grounds to nothing of either kind+            // and covers at pass time (Req 1.4).+            return StubCharacterExtractionModelClient(result: ExtractionResult())         case "unavailable":             return StubCharacterExtractionModelClient(                 availability: .unavailable(reason: "UI test"))

diff --git a/Asterism/Asterism/ViewModels/AppLibraryModel.swift b/Asterism/Asterism/ViewModels/AppLibraryModel.swiftindex 3725159..130c6bf 100644--- a/Asterism/Asterism/ViewModels/AppLibraryModel.swift+++ b/Asterism/Asterism/ViewModels/AppLibraryModel.swift@@ -157,8 +157,8 @@ public final class AppLibraryModel {     /// The resolved configuration after successful bootstrap.     private var resolvedConfiguration: LibraryConfiguration?     private var repository: (any LibraryProviding)?-    /// Retains the concrete repository for backup export (conforms to BackupV11SnapshotProviding).-    private var backupRepository: (any BackupV11SnapshotProviding)?+    /// Retains the concrete repository for backup export (conforms to BackupV12SnapshotProviding).+    private var backupRepository: (any BackupV12SnapshotProviding)?     /// A pre-bootstrap failure used to fail closed on invalid debug launch input.     private let startupFailureMessage: String?     /// Seeds only a fresh, explicit temporary configuration used by UI tests.@@ -2083,7 +2083,7 @@ public final class AppLibraryModel {         guard let repo = backupRepository, let config = resolvedConfiguration else { return nil }         let stagingDir = config.rootDirectory             .appending(path: "Library/Caches/BackupExports")-        let exporter = BackupV11Exporter(+        let exporter = BackupV12Exporter(             repository: repo,             stagingDirectory: stagingDir         )@@ -2196,21 +2196,29 @@ public final class AppLibraryModel {         }     } -    /// `character-extraction`: one work whose notes name people, so the-    /// extraction journey has something real to ground against.+    /// `character-extraction`: one work whose notes name people and places, so+    /// the extraction journey has something real to ground against.     ///     /// The text is chosen to make the scripted answer     /// (`UITestLaunchSupport.cannedExtractionResult`) ground: every quote     /// appears verbatim, and both halves of the slash-compound name appear, so     /// the split produces a proposed alias the reader can strike (Decision 5,-    /// Q92). Nothing about the *proposals* is seeded — grounding, assembly,-    /// matching and every decision are the shipping ones.+    /// Q92). `place-extraction` adds two things to the same sentence set — a+    /// capitalised place name (Kestrel Head) that passes the capital-letter+    /// rule (Q42), and a name the scripted answer returns under both kinds+    /// (Selkie), which assembles into Req 1.5's union row. Nothing about the+    /// *proposals* is seeded — grounding, assembly, matching and every decision+    /// are the shipping ones.     private func seedCharactersFixture(in repo: LibraryRepository) async throws {         let entry = try await repo.capture(CaptureDraft(             captureTitle: "Chapter 1 - The Lamp Room",             captureTitleSource: .host,             rawURLString: "https://characters.test/lamp/1",-            note: "Brede rows the tender out at dusk."))+            // The place half of the sentence is what gives a *place* fact a+            // live citation: Kestrel Head's other quote sits in the work's+            // generic notes, which cite no entry, so without this the entry+            // detail's Places section (Req 4.4) could never be reached.+            note: "Brede rows the tender out at dusk, past Kestrel Head."))          let work = try await repo.createWork(             NewWorkDraft(displayTitle: "The Lamp Room", hostname: "characters.test"))@@ -2228,8 +2236,9 @@ public final class AppLibraryModel {                 displayTitle: reloaded.displayTitle,                 typeAssignment: reloaded.typeDisplay.assignment,                 genreTags: reloaded.genreTags,-                genericNotes: "Ada keeps the lighthouse, and the crew call her Nightjar. "-                    + "Brede rows the tender out at dusk.",+                genericNotes: "Ada keeps the lighthouse at Kestrel Head, and the crew call "+                    + "her Nightjar. Brede rows the tender out at dusk. Selkie is moored "+                    + "below the light.",                 workStatus: reloaded.workStatus, readingStatus: reloaded.readingStatus,                 verdict: reloaded.verdict,                 membership: reloaded.membership))

diff --git a/Asterism/Asterism/ViewModels/DuplicateResolutionModel.swift b/Asterism/Asterism/ViewModels/DuplicateResolutionModel.swiftindex f902347..5a6bcb9 100644--- a/Asterism/Asterism/ViewModels/DuplicateResolutionModel.swift+++ b/Asterism/Asterism/ViewModels/DuplicateResolutionModel.swift@@ -79,11 +79,20 @@ public final class DuplicateResolutionModel {     /// through this sheet, exactly as a torn Work or Entry does — chosen-only,     /// with no union (the `.work` arm's write shape, not the `.entry` arm's     /// note-append).-    public var characterVariants: [CharacterVariantChoice] {+    public var characterVariants: [RecordVariantChoice] {         if case .character(_, let variants, _, _) = contract { return variants }         return []     } +    /// `place-extraction` Req 5.3: the same, for a torn place. Its own accessor+    /// rather than one folded onto `characterVariants`, so the sheet's two arms+    /// stay as separate as the contract's are and neither can draw the other's+    /// set.+    public var placeVariants: [RecordVariantChoice] {+        if case .place(_, let variants, _, _) = contract { return variants }+        return []+    }+     public var differingFields: [DuplicateResolutionField] { contract?.differingFields ?? [] }      public var canConfirm: Bool {

diff --git a/Asterism/Asterism/ViewModels/EntryDetailModel.swift b/Asterism/Asterism/ViewModels/EntryDetailModel.swiftindex 63bcde5..e874f91 100644--- a/Asterism/Asterism/ViewModels/EntryDetailModel.swift+++ b/Asterism/Asterism/ViewModels/EntryDetailModel.swift@@ -144,10 +144,19 @@ public final class EntryDetailModel {     ///     /// Empty is the ordinary case, and what makes the section absent rather than     /// empty.-    public var citingCharacters: [EntryCitingCharacter] {+    public var citingCharacters: [EntryCitingRecord] {         teachingDetail?.citingCharacters ?? []     } +    /// `place-extraction` Req 4.4: the places holding a fact that cites this+    /// entry, in name order — a section of its own beside the characters (Q16).+    ///+    /// Off the same teaching detail and so the same locked read: two sections+    /// about one note must not be able to describe two different moments.+    public var citingPlaces: [EntryCitingRecord] {+        teachingDetail?.citingPlaces ?? []+    }+     /// Whether this entry's Site retains rules that failed validation (Q39,     /// T-1949). This used to fail the whole screen — `.quarantined` was thrown     /// out of `entryTeachingDetail` and this Entry looked deleted (`Unavailability

diff --git a/Asterism/Asterism/ViewModels/MaintenanceViewModels.swift b/Asterism/Asterism/ViewModels/MaintenanceViewModels.swiftindex cf36033..0f506ca 100644--- a/Asterism/Asterism/ViewModels/MaintenanceViewModels.swift+++ b/Asterism/Asterism/ViewModels/MaintenanceViewModels.swift@@ -441,14 +441,23 @@ public final class LibraryDiagnosticsModel {     /// Req 9.3's rows for a duplicate set: what it is, how many records, and     /// the route named rather than "no merge exists".     private static func row(_ item: DuplicateReviewItem) -> Row {-        // Three record types now, not two (`character-extraction` Req 6.5): the+        // Four record types now (`place-extraction` Req 3.5): the         // work-else-entry ternary this replaces called a torn character an         // entry, which sends the reader looking for a note that does not exist.         let noun: String         let plural: String         switch item.recordType {         case .work: (noun, plural) = ("work", "works")-        case .character: (noun, plural) = ("character", "characters")+        // Through `RecordKindPresentation`, which is where a record kind becomes+        // words everywhere else.+        case .character:+            (noun, plural) = (+                RecordKindPresentation.noun(.character), RecordKindPresentation.plural(.character)+            )+        case .place:+            (noun, plural) = (+                RecordKindPresentation.noun(.place), RecordKindPresentation.plural(.place)+            )         // The rule types never reach a review item — they collapse silently —         // but the switch has to be total, and "entry" is what the ternary this         // replaces already said about them.

diff --git a/Asterism/Asterism/ViewModels/SettingsBackupModel.swift b/Asterism/Asterism/ViewModels/SettingsBackupModel.swiftindex c599a71..8698d7d 100644--- a/Asterism/Asterism/ViewModels/SettingsBackupModel.swift+++ b/Asterism/Asterism/ViewModels/SettingsBackupModel.swift@@ -5,20 +5,20 @@ import OSLog // MARK: - Backup Exporting Protocol  /// Test seam abstracting the exporter's operations needed by the Settings-/// surface. Conforms `BackupV11Exporter` to this protocol via extension below.+/// surface. Conforms `BackupV12Exporter` to this protocol via extension below. ///-/// Settings exports 11/12 (`work-creators` Req 9.1): the archive-/// carries a Work's site memberships, the reader's dismissed pairs, citations-/// that name a rule by UUID alone, and the Work's two statuses and verdict. It-/// is also the only format the app reads, so there is one exporter and one-/// importer.+/// Settings exports 12/13 (`place-extraction` Req 5.1): the archive+/// carries the reader's named places and their suppressions, a Work's site+/// memberships, the reader's dismissed pairs, citations that name a rule by UUID+/// alone, and the Work's two statuses and verdict. It is also the only format+/// the app reads, so there is one exporter and one importer. public protocol BackupExporting: Sendable {-    func export(metadata: BackupV11Metadata) async throws -> BackupExportResult+    func export(metadata: BackupV12Metadata) async throws -> BackupExportResult     func cleanup(_ result: BackupExportResult)     func scavengeStaleFiles() } -extension BackupV11Exporter: BackupExporting {}+extension BackupV12Exporter: BackupExporting {}  // MARK: - Settings Backup View Model @@ -79,7 +79,7 @@ public final class SettingsBackupModel {         currentResult = nil          do {-            let metadata = BackupV11Metadata(+            let metadata = BackupV12Metadata(                 appBuild: Self.currentAppBuild(),                 exportedAt: Date()             )@@ -92,7 +92,7 @@ public final class SettingsBackupModel {             state = .failed             // Privacy-safe: log only the error category, never user content             errorMessage = Self.privacySafeMessage(for: error)-            if let exportError = error as? BackupV11ExportError,+            if let exportError = error as? BackupV12ExportError,                case .tornGroups = exportError {                 routesToCheckLibrary = true             }@@ -140,7 +140,7 @@ public final class SettingsBackupModel {         switch error {         case is BackupCodecError:             "Backup export failed due to an encoding error. Please try again."-        case let error as BackupV11ExportError:+        case let error as BackupV12ExportError:             exportMessage(for: error)         default:             "Backup export failed. Please try again."@@ -164,7 +164,7 @@ public final class SettingsBackupModel {     /// (`character-extraction` Req 6.5, Q105). It needs no new sentence: the     /// payload carries a count and a route, not a record kind, and Check Library     /// is where every torn group is resolved.-    private static func exportMessage(for error: BackupV11ExportError) -> String {+    private static func exportMessage(for error: BackupV12ExportError) -> String {         switch error {         case .tornGroups(let payload):             tornGroupsMessage(payload)@@ -204,7 +204,7 @@ public final class SettingsBackupModel {         switch error {         case let e as BackupCodecError:             "codec: \(e)"-        case let e as BackupV11ExportError:+        case let e as BackupV12ExportError:             "export: \(e)"         case let e as LibraryRepositoryError:             "repository: \(e)"

diff --git a/Asterism/Asterism/ViewModels/WorkDetailModel.swift b/Asterism/Asterism/ViewModels/WorkDetailModel.swiftindex b97dda4..c76737e 100644--- a/Asterism/Asterism/ViewModels/WorkDetailModel.swift+++ b/Asterism/Asterism/ViewModels/WorkDetailModel.swift@@ -117,38 +117,61 @@ public final class WorkDetailModel {     /// The work's characters as the repository ordered them, with their facts in     /// Q88's display order. Empty is the ordinary case, and what makes the     /// section absent rather than empty (Req 5.1).-    public var characters: [WorkCharacterPresentation] { presentation?.characters ?? [] }+    public var characters: [WorkRecordPresentation] { presentation?.characters ?? [] }++    /// The work's places, on the same terms (`place-extraction` Req 4.1). The+    /// review sheet previews a reclassification against them (Req 2.3); the+    /// Places section itself is task 23's.+    public var places: [WorkRecordPresentation] { presentation?.places ?? [] }      /// Q88's capture order, for the surfaces that order facts the repository has     /// not already ordered — the review sheet's proposed rows.     public var captureOrder: [UUID: Int] { presentation?.captureOrder ?? [:] } -    /// The reader's intended state for each character, keyed by id.+    /// The reader's intended state for each record of **either** kind, keyed by+    /// id (`place-extraction` design §Edit session).+    ///+    /// One draft set with a kind on each draft, rather than one set per table:+    /// a conversion is then a field on a draft the session already holds, and+    /// the two cards are filtered views of one dictionary.     ///     /// Captured at `load()` — **before** any `save()` reloads the screen (the     /// task list's own note): a draft taken after the reload would be taken from     /// the values the reload published, so an edit made before the metadata save     /// would vanish without a trace.-    public private(set) var characterDrafts: [UUID: CharacterDraft] = [:]+    public private(set) var recordDrafts: [UUID: RecordDraft] = [:]     /// What each draft is compared against, and the basis the commit re-verifies-    /// (Q73).-    private var characterBases: [UUID: CharacterEditBasis] = [:]+    /// (Q73). A basis states the kind the record is stored under, which a+    /// converted draft no longer agrees with — that disagreement *is* the+    /// staged conversion.+    private var recordBases: [UUID: RecordEditBasis] = [:]     /// The order the reader performed things in (Q97). A combine followed by an     /// edit of the target must reach the repository in that order.-    private var stagedCharacterOperations: [StagedCharacterOperation] = []-    /// Whether the last refused character step has somewhere for the reader to+    private var stagedRecordOperations: [StagedRecordOperation] = []+    /// Whether the last refused record step has somewhere for the reader to     /// go — only a torn refusal does (Req 6.5).-    public private(set) var characterRefusalRoutesToCheckLibrary = false+    public private(set) var recordRefusalRoutesToCheckLibrary = false      /// A staged operation, before the drafts it describes are read at commit.     ///-    /// Creates and combines are recorded; updates and deletes are derived from-    /// the drafts at commit, because an edit made three times is still one-    /// update and recording each keystroke would send three.-    private enum StagedCharacterOperation: Equatable {+    /// Creates, combines and conversions are recorded; updates and deletes are+    /// derived from the drafts at commit, because an edit made three times is+    /// still one update and recording each keystroke would send three.+    private enum StagedRecordOperation: Equatable {         case create(id: UUID)         case delete(id: UUID)         case combine(source: UUID, target: UUID)+        /// `place-extraction` Req 3.7: the destination kind is what the reader+        /// chose; the draft rides on it at Save (Q54).+        case convert(id: UUID, to: RecordKind)+    }++    /// One line in an edit-mode collection card: which record, what its draft+    /// holds, and whether the stored row is torn.+    public struct RecordEditLine: Identifiable, Equatable, Sendable {+        public let id: UUID+        public let draft: RecordDraft+        public let isTorn: Bool     }      /// Req 2.8, mirrored from Entry detail: a torn Work's authored fields are@@ -401,7 +424,7 @@ public final class WorkDetailModel {             restoreCreditDraftFromPresentation()             await reloadRoleOptions()             seedLinkTypeDrafts(detail.links)-            adoptCharacterDrafts(detail.characters)+            adoptRecordDrafts(detail.characters + detail.places)             // Before the projection below, which is *about* the selected site.             resetWorkURLHostnameIfNeeded()             state = .ready@@ -1287,7 +1310,7 @@ public final class WorkDetailModel {     /// gave the field.     public func cancelEditing() {         // The mode goes first: the X *is* the reader's discard, and-        // `adoptCharacterDrafts` refuses to replace the drafts of a session that+        // `adoptRecordDrafts` refuses to replace the drafts of a session that         // is still open.         isEditing = false         restoreDraftsFromSnapshot()@@ -1327,30 +1350,38 @@ public final class WorkDetailModel {             guard await commitWorkURLDraft() else { return }             committedURL = true         }-        // Derived once. It JSON-encodes every character's facts to decide what+        // Derived once. It JSON-encodes every record's facts to decide what         // differs, and the state it reads cannot move between here and the-        // commit: `adoptCharacterDrafts` refuses to touch a staged session, and-        // the metadata save below skips its reload when a character step-        // follows.-        let characterOperations = stagedCharacterEdits()-        let hasCharacterChanges = !characterOperations.isEmpty+        // commit: `adoptRecordDrafts` refuses to touch a staged session, and+        // the metadata save below skips its reload when a record step follows.+        let recordOperations = stagedRecordEdits()+        let hasRecordChanges = !recordOperations.isEmpty         let hadMetadataChanges = hasUnsavedChanges          if hadMetadataChanges {-            // One reload, not two: the character step is the last write, so when+            // One reload, not two: the record step is the last write, so when             // one follows, its reload is the one that publishes everything.-            await save(reloading: !hasCharacterChanges)+            await save(reloading: !hasRecordChanges)             // Both halves of a refusal keep the editor open: the sentence that             // has no field to sit under, and the one that sits under the             // position field.             guard errorMessage == nil, positionRefusal == nil else { return }         }-        guard await commitCharacterStep(characterOperations) else { return }+        guard await commitRecordStep(recordOperations) else { return }          // Dropped before the reload, so the re-adopt below is allowed to replace         // the drafts with what the store now holds.         isEditing = false-        if hasCharacterChanges || (committedURL && !hadMetadataChanges) {+        if hasRecordChanges {+            // `place-extraction` Q55: the app is told **before** the reload. The+            // coordinator's `reconcile()` is reached only through+            // `refreshDiagnosesAndSnapshots`, and a held bundle targeting a+            // record this step deleted or converted has to go with it. Without+            // this the bundle stood until the next arrival — harmless, because+            // the commit gate refuses it, but visible.+            await onMutation()+        }+        if hasRecordChanges || (committedURL && !hadMetadataChanges) {             await load()         }     }@@ -1376,7 +1407,7 @@ public final class WorkDetailModel {         // The session that could have auto-reverted is over.         autoRevertedReading = false         finishedReadingPrompt = nil-        adoptCharacterDrafts(presentation?.characters ?? [])+        adoptRecordDrafts((presentation?.characters ?? []) + (presentation?.places ?? []))     }      // MARK: - The finished-reading rule (Decision 1, Reqs 3.1–3.5)@@ -1475,54 +1506,94 @@ public final class WorkDetailModel {         if prompt.thenCommits { await commitEditing() }     } -    // MARK: - The character edit session (Reqs 3.2, 3.7, 5.3)+    // MARK: - The record edit session (Reqs 3.2, 3.7, 5.3; `place-extraction` 3.2, 3.7) -    /// Whether the reader has a character edit session in progress — staged-    /// creates, deletes or combines (Q97), or a draft that no longer matches the-    /// basis it was taken from.+    /// Whether the reader has a record edit session in progress — staged+    /// creates, deletes, combines or conversions (Q97), or a draft that no+    /// longer matches the basis it was taken from.     ///     /// **This is where the "do not clobber the drafts" invariant lives.** It     /// used to live at the one call site that could trip it, as a     /// capture-save-restore around the metadata save; stated here it holds for     /// every reload, including ones added later.-    private var hasStagedCharacterSession: Bool {+    private var hasStagedRecordSession: Bool {         guard isEditing else { return false }-        if !stagedCharacterOperations.isEmpty { return true }-        return characterDrafts.contains { id, draft in-            guard let basis = characterBases[id] else { return false }+        if !stagedRecordOperations.isEmpty { return true }+        return recordDrafts.contains { id, draft in+            guard let basis = recordBases[id] else { return false }             return Self.differs(draft, from: basis)         }     } -    private func adoptCharacterDrafts(_ characters: [WorkCharacterPresentation]) {+    private func adoptRecordDrafts(_ records: [WorkRecordPresentation]) {         // A reload in the middle of an open session would replace the reader's         // drafts with the stored values and drop the staged operations — the         // edits this session exists to commit, gone without a trace. The reader         // discards through the X, which leaves edit mode first.-        guard !hasStagedCharacterSession else { return }-        characterDrafts = Dictionary(-            uniqueKeysWithValues: characters.map { character in-                (character.id,-                 CharacterDraft(-                    name: character.name, note: character.note, aliases: character.aliases,-                    facts: character.facts.map(\.fact)))+        guard !hasStagedRecordSession else { return }+        recordDrafts = Dictionary(+            uniqueKeysWithValues: records.map { record in+                (record.id,+                 RecordDraft(+                    kind: record.kind, name: record.name, note: record.note,+                    aliases: record.aliases, facts: record.facts.map(\.fact)))             })-        characterBases = Dictionary(-            uniqueKeysWithValues: characters.map { ($0.id, $0.editBasis) })-        stagedCharacterOperations = []-        characterRefusalRoutesToCheckLibrary = false+        recordBases = Dictionary(+            uniqueKeysWithValues: records.map { ($0.id, $0.editBasis) })+        stagedRecordOperations = []+        recordRefusalRoutesToCheckLibrary = false+    }++    public func recordDraft(for id: UUID) -> RecordDraft? { recordDrafts[id] }++    /// The two cards' filtered views of the one draft set. A converted record+    /// leaves one and joins the other the moment the reader taps, which is what+    /// makes the correction visible before it is written.+    public var characterDrafts: [UUID: RecordDraft] { recordDrafts.filter { $0.value.kind == .character } }+    public var placeDrafts: [UUID: RecordDraft] { recordDrafts.filter { $0.value.kind == .place } }++    /// The records of one kind, as the page shows them.+    private func presentedRecords(of kind: RecordKind) -> [WorkRecordPresentation] {+        switch kind {+        case .character: characters+        case .place: places+        }+    }++    /// The stored record of either kind with this id, or nil for one this+    /// session created.+    private func presentedRecord(id: UUID) -> WorkRecordPresentation? {+        characters.first { $0.id == id } ?? places.first { $0.id == id }     } -    public func characterDraft(for id: UUID) -> CharacterDraft? { characterDrafts[id] }+    /// One collection card's lines: the stored records whose **draft** is of+    /// this kind, in the order the read gave them, then the ones this session+    /// created, in the order the reader added them.+    ///+    /// Keyed off the draft rather than off the presentation, because that is+    /// the whole of what a staged conversion changes on this screen.+    public func editLines(of kind: RecordKind) -> [RecordEditLine] {+        var lines = (characters + places).compactMap { record -> RecordEditLine? in+            guard let draft = recordDrafts[record.id], draft.kind == kind else { return nil }+            return RecordEditLine(id: record.id, draft: draft, isTorn: record.isTorn)+        }+        lines += createdRecordIDs(of: kind).compactMap { id in+            recordDrafts[id].map { RecordEditLine(id: id, draft: $0, isTorn: false) }+        }+        return lines+    } -    /// The characters this session created, in the order the reader added them.+    /// The records of one kind this session created, in the order the reader+    /// added them.     ///     /// Derived from the staged operations rather than from the draft dictionary:     /// a dictionary has no order, and the screen sorting its keys by     /// `uuidString` dropped each new row into a random place among the others.-    public var createdCharacterIDs: [UUID] {-        stagedCharacterOperations.compactMap { staged in-            guard case .create(let id) = staged, characterDrafts[id] != nil else { return nil }+    /// The *draft's* kind decides which card a new row sits on, so+    /// create-then-convert moves it without a second operation (Q54).+    public func createdRecordIDs(of kind: RecordKind) -> [UUID] {+        stagedRecordOperations.compactMap { staged in+            guard case .create(let id) = staged, recordDrafts[id]?.kind == kind else { return nil }             return id         }     }@@ -1533,97 +1604,174 @@ public final class WorkDetailModel {     /// holds the library rather than routing through this model.     public var libraryForReview: any LibraryProviding { library } -    /// Req 5.3's read-only gate, per character: a torn character is read-only-    /// until its resolution, and so is every character while the *work* is torn.-    public func canEditCharacter(id: UUID) -> Bool {+    /// Req 5.3's read-only gate, per record: a torn record is read-only until+    /// its resolution, and so is every record while the *work* is torn.+    public func canEditRecord(id: UUID) -> Bool {         guard !isReadOnly else { return false }-        return characters.first { $0.id == id }?.isTorn == false+        return presentedRecord(id: id)?.isTorn == false     } -    /// Who this character may be combined into (Req 3.7): every other editable-    /// character of the work. A torn character refuses on either side, so it is-    /// offered on neither.-    public func combineTargets(for id: UUID) -> [WorkCharacterPresentation] {-        guard canEditCharacter(id: id) else { return [] }-        return characters.filter { $0.id != id && canEditCharacter(id: $0.id) }+    /// Whether this record has a conversion staged (`place-extraction` Req 3.7).+    public func isConverted(id: UUID) -> Bool { convertedRecordIDs.contains(id) }++    /// The staged conversions as a set. A session holds a handful of+    /// operations, but `combineTargets` asks `isConverted` once per candidate,+    /// so the linear scan was quadratic in the work's records for no reason.+    private var convertedRecordIDs: Set<UUID> {+        Set(stagedRecordOperations.compactMap { staged in+            if case .convert(let id, _) = staged { return id }+            return nil+        })     } -    public func updateCharacterDraft(id: UUID, _ edit: (inout CharacterDraft) -> Void) {-        guard var draft = characterDrafts[id] else { return }+    /// Who this record may be combined into (Req 3.7): every other editable+    /// record **of its own kind**. A torn record refuses on either side, so it+    /// is offered on neither; a converted record and one created in this+    /// session are offered on neither either, because the UUID a combine names+    /// is one the commit has not minted yet (Q54).+    public func combineTargets(for id: UUID) -> [WorkRecordPresentation] {+        let converted = convertedRecordIDs+        guard canEditRecord(id: id), !converted.contains(id),+              let kind = recordDrafts[id]?.kind+        else { return [] }+        return presentedRecords(of: kind).filter {+            $0.id != id && canEditRecord(id: $0.id) && !converted.contains($0.id)+        }+    }++    public func updateRecordDraft(id: UUID, _ edit: (inout RecordDraft) -> Void) {+        guard var draft = recordDrafts[id] else { return }         edit(&draft)-        characterDrafts[id] = draft+        recordDrafts[id] = draft     }      /// Deleting a fact is expressed by its absence from the draft (Q50): the     /// commit suppresses the triple of every fact the basis had and the draft     /// does not.-    public func deleteFact(_ identity: CharacterFactIdentity, from id: UUID) {-        updateCharacterDraft(id: id) { draft in+    public func deleteFact(_ identity: RecordFactIdentity, from id: UUID) {+        updateRecordDraft(id: id) { draft in             draft.facts.removeAll { $0.identity == identity }         }     }      @discardableResult-    public func addCharacter(named name: String) -> UUID {+    public func addCharacter(named name: String) -> UUID { addRecord(.character, named: name) }++    /// `place-extraction` Req 3.2's "Add a place", on the "Add a character"+    /// footer's terms.+    @discardableResult+    public func addPlace(named name: String) -> UUID { addRecord(.place, named: name) }++    /// The body both wrappers above share, and what a caller holding a `kind`+    /// calls directly rather than branching on it.+    @discardableResult+    public func addRecord(_ kind: RecordKind, named name: String) -> UUID {         // A local id for the session only. The row's real UUID is minted by the         // repository at commit, along with its retained key (Q46).         let id = UUID()-        characterDrafts[id] = CharacterDraft(name: name)-        stagedCharacterOperations.append(.create(id: id))+        recordDrafts[id] = RecordDraft(kind: kind, name: name)+        stagedRecordOperations.append(.create(id: id))         return id     } -    public func deleteCharacter(id: UUID) {-        characterDrafts[id] = nil-        if let index = stagedCharacterOperations.firstIndex(of: .create(id: id)) {+    public func deleteRecord(id: UUID) {+        recordDrafts[id] = nil+        if let index = stagedRecordOperations.firstIndex(of: .create(id: id)) {             // Created and deleted in one session: neither ever existed, and             // sending both would ask the repository to suppress a key it just             // minted.-            stagedCharacterOperations.remove(at: index)+            stagedRecordOperations.remove(at: index)             return         }-        stagedCharacterOperations.append(.delete(id: id))+        // Q54: converted and then deleted in one session is a plain delete —+        // the conversion never happened, so the row goes under the kind it is+        // stored as.+        stagedRecordOperations.removeAll { staged in+            if case .convert(let converted, _) = staged { return converted == id }+            return false+        }+        stagedRecordOperations.append(.delete(id: id))     }      /// Q97: staged in the edit session and discardable by its X until commit.     /// The source leaves the page as soon as it is staged, so the reader sees     /// what they asked for before it lands.-    public func combineCharacter(source: UUID, into target: UUID) {-        guard canEditCharacter(id: source), canEditCharacter(id: target) else { return }-        characterDrafts[source] = nil-        stagedCharacterOperations.append(.combine(source: source, target: target))+    public func combineRecord(source: UUID, into target: UUID) {+        // The offered list is the gate: it already refuses a torn record on+        // either side, a target of the other kind, and anything converted or+        // created in this session.+        guard combineTargets(for: source).contains(where: { $0.id == target }) else { return }+        recordDrafts[source] = nil+        stagedRecordOperations.append(.combine(source: source, target: target))+    }++    /// `place-extraction` Req 3.7, Decision 1: the reader's correction of a+    /// record filed under the wrong kind, **staged** like every other+    /// structural action and applied by the session's one Save.+    ///+    /// The draft's kind flips at once, so the line moves cards under the+    /// reader's finger; tapping again takes the conversion back. A record this+    /// session created is not converted at all — it is created under the other+    /// kind, which is what the flipped draft already says (Q54).+    public func convertRecord(id: UUID) {+        guard let draft = recordDrafts[id] else { return }+        // A created record has no stored row, so no basis and no tornness; the+        // gate is the work's alone.+        let isCreated = recordBases[id] == nil+        guard isCreated ? !isReadOnly : canEditRecord(id: id) else { return }++        if let index = stagedRecordOperations.firstIndex(where: { staged in+            if case .convert(let converted, _) = staged { return converted == id }+            return false+        }) {+            stagedRecordOperations.remove(at: index)+            recordDrafts[id]?.kind = recordBases[id]?.kind ?? draft.kind+            return+        }++        let destination = draft.kind.other+        recordDrafts[id]?.kind = destination+        guard !isCreated else { return }+        stagedRecordOperations.append(.convert(id: id, to: destination))     }      /// The session's operations, in the order the reader performed them.     ///-    /// Updates and deletes of characters that already existed are derived here+    /// Updates and deletes of records that already existed are derived here     /// rather than recorded as they happen: an edit made three times is one-    /// update, and the draft is the intended state either way. Creates and-    /// combines carry their own position, because their order against each-    /// other is what Q97 is about.-    private func stagedCharacterEdits() -> [CharacterEditOperation] {-        var operations: [CharacterEditOperation] = []+    /// update, and the draft is the intended state either way. Creates,+    /// combines and conversions carry their own position, because their order+    /// against each other is what Q97 is about.+    private func stagedRecordEdits() -> [RecordEditOperation] {+        var operations: [RecordEditOperation] = []         var handled: Set<UUID> = []-        for staged in stagedCharacterOperations {+        for staged in stagedRecordOperations {             switch staged {             case .create(let id):-                guard let draft = characterDrafts[id] else { continue }+                guard let draft = recordDrafts[id] else { continue }                 operations.append(.create(draft))                 handled.insert(id)             case .delete(let id):-                guard let basis = characterBases[id] else { continue }+                guard let basis = recordBases[id] else { continue }                 operations.append(.delete(basis: basis))                 handled.insert(id)             case .combine(let source, let target):-                guard let sourceBasis = characterBases[source],-                      let targetBasis = characterBases[target]+                guard let sourceBasis = recordBases[source],+                      let targetBasis = recordBases[target]                 else { continue }                 operations.append(.combine(source: sourceBasis, target: targetBasis))                 handled.insert(source)+            case .convert(let id, let destination):+                // Q54: the draft as it stands at Save rides on the convert, so+                // an edit made after it needs no `.update` naming a UUID the+                // commit has not minted yet.+                guard let basis = recordBases[id], let draft = recordDrafts[id] else { continue }+                operations.append(.convert(basis: basis, to: destination, draft: draft))+                handled.insert(id)             }         }-        for (id, draft) in characterDrafts.sorted(by: { $0.key.uuidString < $1.key.uuidString }) {-            guard !handled.contains(id), let basis = characterBases[id] else { continue }+        for (id, draft) in recordDrafts.sorted(by: { $0.key.uuidString < $1.key.uuidString }) {+            guard !handled.contains(id), let basis = recordBases[id] else { continue }             guard Self.differs(draft, from: basis) else { continue }             operations.append(.update(basis: basis, draft: draft))         }@@ -1631,32 +1779,33 @@ public final class WorkDetailModel {     }      /// A draft differs from its basis when the basis it *would* produce differs.-    /// Comparing through `CharacterEditBasis` rather than field by field is what+    /// Comparing through `RecordEditBasis` rather than field by field is what     /// makes a re-ordered fact list not a change: the basis canonicalises the     /// facts and sorts the aliases (Q75), and the repository compares the same     /// way.-    private static func differs(_ draft: CharacterDraft, from basis: CharacterEditBasis) -> Bool {-        CharacterEditBasis(-            characterID: basis.characterID, name: draft.name, note: draft.note,+    private static func differs(_ draft: RecordDraft, from basis: RecordEditBasis) -> Bool {+        RecordEditBasis(+            kind: basis.kind, recordID: basis.recordID, name: draft.name, note: draft.note,             aliases: draft.aliases, facts: draft.facts) != basis     } -    /// The one repository call the session's character changes go through.+    /// The one repository call the session's record changes go through, of+    /// either kind and conversions included (Q47).     /// Returns false where the step refused, which keeps the editor open.-    private func commitCharacterStep(_ operations: [CharacterEditOperation]) async -> Bool {+    private func commitRecordStep(_ operations: [RecordEditOperation]) async -> Bool {         guard !operations.isEmpty else { return true }-        characterRefusalRoutesToCheckLibrary = false+        recordRefusalRoutesToCheckLibrary = false         do {-            let outcome = try await library.commitCharacterEdits(+            let outcome = try await library.commitRecordEdits(                 workID: workID, operations: operations)             switch outcome {             case .committed:-                stagedCharacterOperations = []+                stagedRecordOperations = []                 return true             case .refused(let refusal):-                errorMessage = Self.characterRefusalMessage(refusal)-                if case .torn = refusal { characterRefusalRoutesToCheckLibrary = true }-                if case .workTorn = refusal { characterRefusalRoutesToCheckLibrary = true }+                errorMessage = recordRefusalMessage(refusal)+                if case .torn = refusal { recordRefusalRoutesToCheckLibrary = true }+                if case .workTorn = refusal { recordRefusalRoutesToCheckLibrary = true }                 state = .error(message: errorMessage ?? "")                 return false             }@@ -1664,14 +1813,14 @@ public final class WorkDetailModel {             errorMessage = error.localizedDescription             state = .error(message: error.localizedDescription)             Self.logger.error(-                "Character edit step failed: \(String(describing: error), privacy: .public)")+                "Record edit step failed: \(String(describing: error), privacy: .public)")             return false         }     } -    /// Q73: the whole step refuses, and the message names the character so the+    /// Q73: the whole step refuses, and the message names the record so the     /// reader knows which of their edits is the one in question.-    private static func characterRefusalMessage(_ refusal: CharacterEditRefusal) -> String {+    private func recordRefusalMessage(_ refusal: RecordEditRefusal) -> String {         switch refusal {         case .basisMismatch(_, let name):             "\(name) changed elsewhere while you were editing, so nothing was saved. "@@ -1685,18 +1834,32 @@ public final class WorkDetailModel {             // nothing about a refusal they can act on.             "This work now exists in differing copies, so nothing was saved. "                 + "Open Check Library to choose which copy to keep."-        case .characterGone:-            "That character was deleted elsewhere, so nothing was saved."+        case .recordGone(let recordID):+            // The noun is the record's own: a place reported as a deleted+            // character would send the reader to the wrong card.+            "That \(RecordKindPresentation.noun(storedKind(of: recordID))) was deleted "+                + "elsewhere, so nothing was saved."         case .workGone:             "This work was deleted elsewhere, so nothing was saved."+        case .kindMismatch:+            // Unreachable from these views: the editor knows its own kind and+            // the combine target list is per kind. Worded for the reader all the+            // same, because a message the reader cannot act on still beats none.+            "That record's kind changed while you were editing, so nothing was saved."         }     } +    /// The kind the store holds this record under — the basis's, not the+    /// draft's, so a staged conversion does not rename a refusal's subject.+    private func storedKind(of recordID: UUID) -> RecordKind {+        recordBases[recordID]?.kind ?? recordDrafts[recordID]?.kind ?? .character+    }+     /// Commits metadata edit. Suppresses duplicate submissions.     public func save() async { await save(reloading: true) }      /// - Parameter reloading: whether a successful write re-reads the screen.-    ///   False only inside `commitEditing()`, where a character step follows and+    ///   False only inside `commitEditing()`, where a record step follows and     ///   its own reload is the one that publishes both halves — two full     ///   `workDetail` reads for one confirmation is one too many.     private func save(reloading: Bool) async {@@ -1771,7 +1934,7 @@ public final class WorkDetailModel {                 //                 // Not a `load()`. That re-reads the record and reassigns every                 // draft — the title, the tags, the notes, the two statuses, the-                // verdict, the series draft and the staged character+                // verdict, the series draft and the staged record                 // operations — so a reader who had retitled the work and                 // written a verdict before picking a series another device had                 // just deleted would lose all of it. Req 2.4 is the one@@ -1800,7 +1963,7 @@ public final class WorkDetailModel {                 // so the picker's rows are wrong and the draft names a creator                 // no row backs. Exactly that is refreshed and exactly that is                 // dropped — never a `load()`, which would take the title, the-                // tags, the verdict and the staged character edits with it.+                // tags, the verdict and the staged record edits with it.                 if case .creatorMissing(_, let missingCreatorID) = conflict {                     await loadCreatorOptions()                     removeCredit(for: missingCreatorID)@@ -1829,8 +1992,8 @@ public final class WorkDetailModel {             // The drafts stay, exactly as on the `.conflict` path above: nothing             // was written, the editor is still open, and the draft is the only             // copy of itself until it lands. Restoring from the snapshot here-            // re-adopted the stored characters and so silently threw away the-            // session's staged character operations as well as the typed fields.+            // re-adopted the stored records and so silently threw away the+            // session's staged record operations as well as the typed fields.             state = .error(message: error.localizedDescription)             Self.logger.error("Work update failed: \(String(describing: error), privacy: .public)")         }

diff --git a/Asterism/Asterism/Views/CharacterEditorView.swift b/Asterism/Asterism/Views/CharacterEditorView.swiftindex 0702d0d..c58932c 100644--- a/Asterism/Asterism/Views/CharacterEditorView.swift+++ b/Asterism/Asterism/Views/CharacterEditorView.swift@@ -2,25 +2,30 @@ import AsterismCore import ConstellationKit import SwiftUI -/// One character's editor (`character-extraction` Req 5.3), opened by tapping-/// its line in the Characters card — or by "Add a character", which mints a-/// draft and opens it for naming.+/// One record's editor (`character-extraction` Req 5.3, `place-extraction`+/// Reqs 3.2, 3.7), opened by tapping its line in the Characters or Places+/// card — or by "Add a character" / "Add a place", which mints a draft and+/// opens it for naming. ///-/// Everything the inline editor card drew, unchanged in what it writes: the-/// name and note fields, the aliases, the facts, the torn notice, and the two-/// structural actions. The card is gone from the page because a cast of ten-/// pills with one open editor under them was the section that could not fit.+/// One view for both kinds, parameterised by `kind` (design §Views): every word+/// it says comes from `RecordKindPresentation`, so the two collections cannot+/// come to describe themselves differently. `kind` is the kind the **draft** is+/// under, which a staged conversion has already flipped. ///-/// The edit session's draft state stays the model's (`characterDraft(for:)`,-/// `updateCharacterDraft`), so nothing here is written until the work's own+/// The edit session's draft state stays the model's (`recordDraft(for:)`,+/// `updateRecordDraft`), so nothing here is written until the work's own /// checkmark commits — the torn read-only gate and the conflict handling are /// the model's as before. struct CharacterEditorView: View {     let model: WorkDetailModel-    let characterID: UUID+    let recordID: UUID+    /// Which collection this editor is drawing. Passed in rather than read off+    /// the draft so the sheet keeps one identity for one presentation; a+    /// conversion dismisses it, because the line it opened from has gone.+    let kind: RecordKind     /// Where the reader is taken when a combine finishes: the target's editor,-    /// because the source's name just left the cast and the reader has to see-    /// where everything went.+    /// because the source's name just left the collection and the reader has to+    /// see where everything went.     let onCombined: (UUID) -> Void      @Environment(\.dismiss) private var dismiss@@ -28,41 +33,53 @@ struct CharacterEditorView: View {     /// behind the sheet: a dialog raised back there would be covered by this.     @State private var isCombining = false -    /// The stored character this draft belongs to, or nil for one created in-    /// this session — which has no stored row yet and so cannot be torn.-    private var character: WorkCharacterPresentation? {-        model.characters.first { $0.id == characterID }+    /// The stored record this draft belongs to, or nil for one created in this+    /// session — which has no stored row yet and so cannot be torn.+    private var record: WorkRecordPresentation? {+        model.characters.first { $0.id == recordID } ?? model.places.first { $0.id == recordID }     } -    private var draft: CharacterDraft? { model.characterDraft(for: characterID) }+    private var draft: RecordDraft? { model.recordDraft(for: recordID) } -    /// The per-character read-only gate, which is not the work's: a torn-    /// character is off limits while the rest of the cast is editable.+    /// The per-record read-only gate, which is not the work's: a torn record is+    /// off limits while the rest of the collection is editable.     private var editable: Bool {-        character.map { model.canEditCharacter(id: $0.id) } ?? !model.isReadOnly+        record.map { model.canEditRecord(id: $0.id) } ?? !model.isReadOnly     } +    /// The kind the store holds this record under. A conversion is staged, so+    /// this and the draft's kind disagree exactly while one is staged.+    private var storedKind: RecordKind { record?.kind ?? kind }++    /// Req 3.7: conversion is offered on a stored row the reader may edit. A+    /// torn record has no single content a conversion could carry (Q39), and a+    /// record created in this session is *created* under the other kind rather+    /// than converted (Q54), so neither is offered it.+    private var offersConversion: Bool { record != nil && editable }+     var body: some View {         let draft = self.draft+        // Once per body: `structuralActions` asks whether there are any and the+        // dialog lists them, and the model derives the answer from the staged+        // operations each time it is asked.+        let combineTargets = model.combineTargets(for: recordID)         return ConstellationEditorSheet(             title: title(draft),             identifier: "character-editor"         ) {             if let draft {                 Section {-                    TextField("Name", text: characterBinding(\.name))+                    TextField("Name", text: recordBinding(\.name))                         .disabled(!editable)                         .frame(minHeight: AsterismLayout.minHitTarget)                         .accessibilityIdentifier("work-detail-character-name-field")-                    TextField("Note", text: characterBinding(\.note), axis: .vertical)+                    TextField("Note", text: recordBinding(\.note), axis: .vertical)                         .disabled(!editable)                         .lineLimit(1...4)                         .accessibilityIdentifier("work-detail-character-note-field")                 } footer: {-                    if character?.isTorn == true {-                        Text(-                            "This character exists in differing copies — editing is off until "-                                + "you choose which one to keep.")+                    if record?.isTorn == true {+                        Text(RecordKindPresentation.tornNotice(storedKind))                             .foregroundStyle(AsterismColors.amberText)                             .accessibilityIdentifier("work-detail-character-torn-notice")                     }@@ -76,12 +93,12 @@ struct CharacterEditorView: View {                         aliases: draft.aliases,                         editable: editable,                         onRemove: { alias in-                            model.updateCharacterDraft(id: characterID) { draft in+                            model.updateRecordDraft(id: recordID) { draft in                                 draft.aliases.removeAll { $0 == alias }                             }                         },                         onAdd: { alias in-                            model.updateCharacterDraft(id: characterID) { draft in+                            model.updateRecordDraft(id: recordID) { draft in                                 guard !draft.aliases.contains(alias) else { return }                                 draft.aliases.append(alias)                             }@@ -102,7 +119,7 @@ struct CharacterEditorView: View {                 }                  Section {-                    structuralActions+                    structuralActions(combineTargets: combineTargets)                         .constellationListRow()                 }             }@@ -113,15 +130,15 @@ struct CharacterEditorView: View {         .confirmationDialog(             "Combine into", isPresented: $isCombining, titleVisibility: .visible         ) {-            ForEach(model.combineTargets(for: characterID)) { target in+            ForEach(combineTargets) { target in                 Button(target.name) {-                    model.combineCharacter(source: characterID, into: target.id)+                    model.combineRecord(source: recordID, into: target.id)                     isCombining = false                     onCombined(target.id)                 }-                // The cast lines carry the same character names as labels, so-                // the dialog's choices need their own identity to stay-                // addressable (the dialogButton precedent).+                // The collection's lines carry the same names as labels, so the+                // dialog's choices need their own identity to stay addressable+                // (the dialogButton precedent).                 .accessibilityIdentifier("work-detail-combine-target")             }             Button("Cancel", role: .cancel) { isCombining = false }@@ -130,17 +147,19 @@ struct CharacterEditorView: View {         }     } -    /// What the sheet is called. A draft with no name yet is the one the "Add a-    /// character" button just minted, and it is named by typing into the field-    /// below the title.-    private func title(_ draft: CharacterDraft?) -> String {-        guard let draft, !draft.name.isEmpty else { return "New character" }+    /// What the sheet is called. A draft with no name yet is the one the "Add+    /// a …" button just minted, and it is named by typing into the field below+    /// the title.+    private func title(_ draft: RecordDraft?) -> String {+        guard let draft, !draft.name.isEmpty else {+            return RecordKindPresentation.newRecordTitle(kind)+        }         return draft.name     }      /// One fact, with the way to drop it. The statement is the reader's own     /// sentence, so it wraps rather than truncates.-    private func factRow(_ fact: CharacterFact) -> some View {+    private func factRow(_ fact: RecordFact) -> some View {         HStack(alignment: .top, spacing: 8) {             Text(fact.statement)                 .font(.footnote)@@ -148,7 +167,7 @@ struct CharacterEditorView: View {                 .fixedSize(horizontal: false, vertical: true)                 .frame(maxWidth: .infinity, alignment: .leading)             Button {-                model.deleteFact(fact.identity, from: characterID)+                model.deleteFact(fact.identity, from: recordID)             } label: {                 Image(systemName: "minus.circle")                     .foregroundStyle(AsterismColors.secondaryText)@@ -164,25 +183,33 @@ struct CharacterEditorView: View {         }     } -    /// Combine and Delete, side by side on the shared bordered recipe: the one-    /// that keeps everything in violet, the one that ends the record in-    /// `secondaryText` with a trash glyph. Neither is system red — §11 gives the+    /// Combine, Convert and Delete on the shared bordered recipe: the two that+    /// keep everything in violet, and the one that ends the record in+    /// `secondaryText` with a trash glyph. None is system red — §11 gives the     /// palette no error hue.+    ///+    /// A `FlowLayout` rather than an `HStack` (Q46 put three actions where two+    /// were): three worded buttons do not fit one phone row at the accessibility+    /// text sizes, and wrapping is what the pill grids on this screen already+    /// do rather than clipping.     @ViewBuilder-    private var structuralActions: some View {-        HStack(spacing: 8) {-            if !model.combineTargets(for: characterID).isEmpty {+    private func structuralActions(+        combineTargets: [WorkRecordPresentation]+    ) -> some View {+        FlowLayout(spacing: 8) {+            if !combineTargets.isEmpty {                 ConstellationFooterButton(title: "Combine into…", systemImage: nil) {                     isCombining = true                 }                 .disabled(!editable)                 .accessibilityIdentifier("work-detail-character-combine")             }+            conversionAction             ConstellationFooterButton(-                title: "Delete character", systemImage: "trash",+                title: RecordKindPresentation.deleteTitle(kind), systemImage: "trash",                 tint: AsterismColors.secondaryText             ) {-                model.deleteCharacter(id: characterID)+                model.deleteRecord(id: recordID)                 dismiss()             }             .disabled(!editable)@@ -190,18 +217,43 @@ struct CharacterEditorView: View {         }     } -    private func characterBinding(-        _ keyPath: WritableKeyPath<CharacterDraft, String>+    /// Req 3.7's third structural action, between Combine and Delete (Q46).+    ///+    /// It writes nothing: the conversion is staged, the line moves to the other+    /// card at once, and the session's one Save applies it. Tapping it again+    /// takes it back, which is why the label changes rather than the button+    /// disappearing.+    @ViewBuilder+    private var conversionAction: some View {+        if offersConversion {+            ConstellationFooterButton(+                title: RecordKindPresentation.convertTitle(+                    from: storedKind, isConverted: model.isConverted(id: recordID)),+                systemImage: "arrow.left.arrow.right"+            ) {+                model.convertRecord(id: recordID)+                // The line has left this card. The sheet closes so the reader+                // sees where it landed — and so this editor is not left drawing+                // a collection the record is no longer in.+                dismiss()+            }+            .disabled(!editable)+            .accessibilityIdentifier("work-detail-character-convert")+        }+    }++    private func recordBinding(+        _ keyPath: WritableKeyPath<RecordDraft, String>     ) -> Binding<String> {         Binding(-            get: { model.characterDraft(for: characterID)?[keyPath: keyPath] ?? "" },+            get: { model.recordDraft(for: recordID)?[keyPath: keyPath] ?? "" },             set: { value in-                model.updateCharacterDraft(id: characterID) { $0[keyPath: keyPath] = value }+                model.updateRecordDraft(id: recordID) { $0[keyPath: keyPath] = value }             })     } } -/// Aliases in the character editor: each a removable chip, plus a field to add+/// Aliases in the record editor: each a removable chip, plus a field to add /// one. Its own view because the add field needs state of its own. struct CharacterAliasEditor: View {     let aliases: [String]

diff --git a/Asterism/Asterism/Views/CharacterReviewView.swift b/Asterism/Asterism/Views/CharacterReviewView.swiftindex d1ee30c..afd3889 100644--- a/Asterism/Asterism/Views/CharacterReviewView.swift+++ b/Asterism/Asterism/Views/CharacterReviewView.swift@@ -2,11 +2,14 @@ import AsterismCore import ConstellationKit import SwiftUI -/// The review list (Reqs 2.1, 2.2, 2.5, 2.7).+/// The review list (`character-extraction` Reqs 2.1, 2.2, 2.5, 2.7;+/// `place-extraction` Reqs 2.1–2.3). ///-/// One section per candidate or bundle, each with its own Keep and Skip. The-/// list is a snapshot taken when the sheet opened, so nothing moves under the-/// reader while they decide.+/// One section per candidate or bundle, of either kind, each with its own Keep+/// and Skip and — where the row is the reader's to re-file — a kind control+/// above them. The list is a snapshot taken when the sheet opened, so nothing+/// moves under the reader while they decide, and a reclassification redraws its+/// own row in place rather than moving it. struct CharacterReviewView: View {     @Bindable var model: CharacterReviewModel     let onDone: () -> Void@@ -22,7 +25,7 @@ struct CharacterReviewView: View {                     reviewContent                 }             }-            .navigationTitle("Suggested characters")+            .navigationTitle("Suggested characters and places")             .toolbar {                 // Every row commits on its own, so this button commits nothing —                 // it leaves the list, and undecided rows stay for a later visit@@ -69,22 +72,62 @@ struct CharacterReviewView: View {             }              ForEach(model.rows) { row in-                Section(header: ConstellationSectionHeader(row.name, accent: .cyan)) {+                Section(header: header(row)) {                     rowContent(row)                 }             }         }     } +    /// Req 2.1: every row says which collection it would join. The name is the+    /// header the sheet has always drawn; the kind is a caption under it, so a+    /// place row is not a character row with a different word in it.+    private func header(_ row: CharacterReviewRow) -> some View {+        VStack(alignment: .leading, spacing: 2) {+            ConstellationSectionHeader(row.name, accent: .cyan)+            Text(RecordKindPresentation.name(row.kind))+                .font(.caption)+                .foregroundStyle(AsterismColors.secondaryText)+                // A Form header uppercases its content; the caption is a word,+                // not a label.+                .textCase(nil)+                .accessibilityIdentifier("character-review-kind-caption-\(row.id)")+        }+    }+     @ViewBuilder     private func rowContent(_ row: CharacterReviewRow) -> some View {         if row.isBundle {-            Text("Adds to a character you already have.")+            Text("Adds to a \(RecordKindPresentation.noun(row.kind)) you already have.")                 .font(.caption)                 .foregroundStyle(.secondary)                 .accessibilityIdentifier("character-review-bundle-note")         } +        // Q41: the model files places as characters often enough that the+        // reader is told when the other collection already answers to this+        // name. It commits nothing and changes no matching — it is the reason+        // the kind control below is worth looking at.+        //+        // Secondary text, not amber: the guide reserves amber for a state the+        // reader has to clear (§Palette, §Never), and this is presentation+        // beside two other resting notes that say what the row is.+        if let hint = row.crossKindHint {+            Text(hint)+                .font(.caption)+                .foregroundStyle(.secondary)+                .accessibilityIdentifier("character-review-hint-\(row.id)")+        }++        // Req 2.1/Q38: its label says one kind, but skipping it decides both+        // (Q23), and the reader must see the wider action before they take it.+        if row.isDualKind {+            Text("Suggested as both a character and a place")+                .font(.caption)+                .foregroundStyle(.secondary)+                .accessibilityIdentifier("character-review-dual-\(row.id)")+        }+         ForEach(row.aliases) { alias in             // Q92: shown and strikeable before accepting, never installed             // silently. "A/B" in these notes is as often a pairing as a second@@ -113,10 +156,10 @@ struct CharacterReviewView: View {         }          if row.proposedFacts.isEmpty, row.aliases.isEmpty {-            Text("A name, with nothing said about them yet.")+            Text(RecordKindPresentation.nameOnlyNote(row.kind))                 .font(.caption)                 .foregroundStyle(.secondary)-                .accessibilityIdentifier("character-review-name-only")+                .accessibilityIdentifier("character-review-name-only-\(row.id)")         }          // Req 2.1: a bundle is shown *beside* what the character already holds,@@ -132,12 +175,36 @@ struct CharacterReviewView: View {             .accessibilityIdentifier("character-review-existing-\(row.id)")         } +        // Req 2.2: the reader's one-tap correction of the model's kind, on the+        // rows that are theirs to re-file. `ConstellationSegmentedControl`+        // rather than a `Picker`: §7 defines the segmented capsule once, and it+        // is the shape that stacks instead of clipping at the accessibility+        // sizes.+        if row.canReclassify {+            ConstellationSegmentedControl(+                values: RecordKind.allCases,+                selection: Binding(+                    get: { row.kind },+                    set: { model.reclassify(row.id, to: $0) }),+                containerLabel: "Record kind",+                title: RecordKindPresentation.name,+                identifier: {+                    RecordKindPresentation.reviewControlIdentifier(rowID: row.id, kind: $0)+                })+                .accessibilityIdentifier("character-review-kind-\(row.id)")+                .disabled(model.isSubmitting)+        }+         HStack(spacing: 12) {             Button("Keep") {                 Task { await model.accept(row.id) }             }             .buttonStyle(.constellationPrimary)             .accessibilityIdentifier("character-review-keep-\(row.id)")+            // Req 2.2: a reclassified row whose facts all deduped away has+            // nothing to keep. It stays, and the skip beside it still decides+            // it.+            .disabled(!row.canAccept)              Button("Skip") {                 Task { await model.skip(row.id) }

diff --git a/Asterism/Asterism/Views/DuplicateResolutionView.swift b/Asterism/Asterism/Views/DuplicateResolutionView.swiftindex 12fe955..c15e8b1 100644--- a/Asterism/Asterism/Views/DuplicateResolutionView.swift+++ b/Asterism/Asterism/Views/DuplicateResolutionView.swift@@ -92,6 +92,13 @@ struct DuplicateResolutionView: View {                 ForEach(model.characterVariants) { variant in                     variantRow(id: variant.id) { characterVariantContent(variant) }                 }+                // `place-extraction` Req 5.3: a torn place is chosen between+                // exactly as a torn character is — same payload, same rows;+                // what differs is the table the commit writes to, which the set+                // key already says.+                ForEach(model.placeVariants) { variant in+                    variantRow(id: variant.id) { characterVariantContent(variant) }+                }             } header: {                 // Decision 1 and Q46: duplicate review is an                 // actionable-attention surface, and this header is the sheet's@@ -174,7 +181,7 @@ struct DuplicateResolutionView: View {     /// a divergent character can hold dozens, and the choice is between copies,     /// not between facts.     @ViewBuilder-    private func characterVariantContent(_ variant: CharacterVariantChoice) -> some View {+    private func characterVariantContent(_ variant: RecordVariantChoice) -> some View {         VStack(alignment: .leading, spacing: 4) {             Text(variant.name.isEmpty ? "(no name)" : variant.name)                 .font(.body)

diff --git a/Asterism/Asterism/Views/EntryDetailView.swift b/Asterism/Asterism/Views/EntryDetailView.swiftindex 2a1b041..b3f4d9a 100644--- a/Asterism/Asterism/Views/EntryDetailView.swift+++ b/Asterism/Asterism/Views/EntryDetailView.swift@@ -175,6 +175,7 @@ struct EntryDetailView: View {             }              citingCharactersSection+            citingPlacesSection              // Q49: last, and collapsed. The capture's site and the             // title-recovery actions — neither is something a reader needs@@ -367,20 +368,38 @@ struct EntryDetailView: View {     /// are edited.     @ViewBuilder     private var citingCharactersSection: some View {-        if !model.citingCharacters.isEmpty {+        citingRecordsSection(model.citingCharacters, kind: .character)+    }++    /// `place-extraction` Req 4.4: the same list for places, directly after the+    /// characters one and separate from it (Q16) — a merged list would need a+    /// kind label on every row for no gain. Absent rather than empty, on the+    /// characters section's terms.+    @ViewBuilder+    private var citingPlacesSection: some View {+        citingRecordsSection(model.citingPlaces, kind: .place)+    }++    @ViewBuilder+    private func citingRecordsSection(+        _ records: [EntryCitingRecord], kind: RecordKind+    ) -> some View {+        if !records.isEmpty {             Section {-                ForEach(model.citingCharacters) { character in-                    LabeledContent(character.name) {-                        Text(Pluralisation.count(character.factCount, "fact", "facts"))+                ForEach(records) { record in+                    LabeledContent(record.name) {+                        Text(Pluralisation.count(record.factCount, "fact", "facts"))                             .font(.caption)                             .foregroundStyle(.secondary)                     }-                    .accessibilityIdentifier("entry-detail-citing-character")+                    .accessibilityIdentifier(+                        "entry-detail-citing-\(RecordKindPresentation.noun(kind))")                     .accessibilityLabel(-                        "\(character.name), \(Pluralisation.count(character.factCount, "fact", "facts")) citing this note")+                        "\(record.name), \(Pluralisation.count(record.factCount, "fact", "facts")) citing this note")                 }             } header: {-                ConstellationSectionHeader("Characters", accent: .violet)+                ConstellationSectionHeader(+                    RecordKindPresentation.collection(kind), accent: .violet)             }         }     }

diff --git a/Asterism/Asterism/Views/RecentView.swift b/Asterism/Asterism/Views/RecentView.swiftindex 4c2bf73..a0bd8b9 100644--- a/Asterism/Asterism/Views/RecentView.swift+++ b/Asterism/Asterism/Views/RecentView.swift@@ -748,12 +748,13 @@ struct RecentDuplicatePlan: Equatable {     }      private static func text(for item: DuplicateReviewItem) -> String {-        // `character-extraction` Req 6.5: a torn character reaches this filter-        // like any other non-Entry set, and the work-shaped sentences below-        // would call it a work. It is resolved in the same sheet, so only the-        // noun changes.-        if item.recordType == .character {-            return "A character arrived more than once and the copies differ. "+        // `character-extraction` Req 6.5, `place-extraction` Req 5.3: a torn+        // character or place reaches this filter like any other non-Entry set,+        // and the work-shaped sentences below would call it a work. Both are+        // resolved in the same sheet, so only the noun changes.+        if item.recordType == .character || item.recordType == .place {+            let noun = item.recordType == .character ? "character" : "place"+            return "A \(noun) arrived more than once and the copies differ. "                 + "Choose which one to keep."         }         switch item.route {

diff --git a/Asterism/Asterism/Views/RecordKindPresentation.swift b/Asterism/Asterism/Views/RecordKindPresentation.swiftnew file mode 100644index 0000000..43d225b--- /dev/null+++ b/Asterism/Asterism/Views/RecordKindPresentation.swift@@ -0,0 +1,130 @@+import AsterismCore+import Foundation++/// The one place a `RecordKind` becomes words (design §Review, §Edit session).+///+/// Beside `WorkStatusPresentation.swift`, and for its reason: the review sheet's+/// section caption and kind control, the work page's two collections, and the+/// editor's own copy all say the same two nouns, and a table each is a chance+/// for them to disagree in a way only a reader would notice.+///+/// `nonisolated` throughout: the entries are pure, and value-type helpers read+/// them from outside the actor under this target's MainActor-by-default+/// isolation.+nonisolated enum RecordKindPresentation {++    /// One record of this kind, as the reader is told it is called — the review+    /// sheet's section caption and the kind control's segment label.+    static func name(_ kind: RecordKind) -> String {+        switch kind {+        case .character: "Character"+        case .place: "Place"+        }+    }++    /// The collection, for a section header or a card caption.+    static func collection(_ kind: RecordKind) -> String {+        switch kind {+        case .character: "Characters"+        case .place: "Places"+        }+    }++    /// The lower-case noun, for a sentence that names one — "a place you already+    /// have".+    static func noun(_ kind: RecordKind) -> String {+        switch kind {+        case .character: "character"+        case .place: "place"+        }+    }++    /// The lower-case plural, for a counted phrase — "two places are the same+    /// thing". `collection(_:)`'s word, cased for the middle of a sentence.+    static func plural(_ kind: RecordKind) -> String { collection(kind).lowercased() }++    /// The review sheet's line for a row that proposes a name and nothing else.+    /// Per kind, because "them" is a thing to say about a character and not+    /// about a place.+    static func nameOnlyNote(_ kind: RecordKind) -> String {+        "A name, with nothing said about this \(noun(kind)) yet."+    }++    /// How a sentence refers back to one: a character is a "them", a place an+    /// "it". The only grammatical difference between the two kinds' copy, and+    /// the reason the sentences below are built here rather than branched on+    /// `kind` at each call site.+    static func objectPronoun(_ kind: RecordKind) -> String {+        switch kind {+        case .character: "them"+        case .place: "it"+        }+    }++    /// The review sheet's Q41 hint: the other kind already answers to this name.+    static func existingNameHint(_ kind: RecordKind) -> String {+        "You already have a \(noun(kind)) with this name"+    }++    /// Req 2.8's re-route disclosure — the row resolved onto a record the+    /// library already holds, so nothing was written.+    static func reRouteDisclosure(_ kind: RecordKind) -> String {+        "This turned out to belong to a \(noun(kind)) you already have, "+            + "so nothing was saved. It is shown against \(objectPronoun(kind)) now."+    }++    /// Req 2.8's torn disclosure, for a refusal that names the record.+    static func tornRecordDisclosure(_ kind: RecordKind) -> String {+        "That \(noun(kind)) exists in differing copies, so nothing can be added to "+            + "\(objectPronoun(kind)) yet. Open Check Library to choose which copy to keep."+    }++    /// The review sheet's kind-control segment identifier, spelled here beside+    /// the label so the journeys and the view read one table.+    static func reviewControlIdentifier(rowID: String, kind: RecordKind) -> String {+        "character-review-kind-\(rowID)-\(kind.rawValue)"+    }++    // MARK: - The editor's copy (`place-extraction` Req 3.7, design §Edit session)++    /// The editor sheet's title for a draft with no name yet — the one "Add a+    /// …" just minted, named by typing into the field below the title.+    static func newRecordTitle(_ kind: RecordKind) -> String {+        switch kind {+        case .character: "New character"+        case .place: "New place"+        }+    }++    /// The editor's delete action.+    static func deleteTitle(_ kind: RecordKind) -> String { "Delete \(noun(kind))" }++    /// The card's footer button on the work editor.+    static func addTitle(_ kind: RecordKind) -> String { "Add a \(noun(kind))" }++    /// The other kind — what a conversion goes to. `RecordKind.other`'s+    /// spelling, kept here so the copy below reads in one vocabulary.+    static func other(_ kind: RecordKind) -> RecordKind { kind.other }++    /// Req 3.7's conversion action, between Combine and Delete. `isConverted`+    /// is the take-it-back wording: the reader is looking at a line that has+    /// already moved cards, so "Make this a place" again would read as a second+    /// conversion.+    static func convertTitle(from kind: RecordKind, isConverted: Bool) -> String {+        isConverted+            ? "Make this a \(noun(kind)) again"+            : "Make this a \(noun(other(kind)))"+    }++    /// The torn notice inside the editor.+    static func tornNotice(_ kind: RecordKind) -> String {+        "This \(noun(kind)) exists in differing copies — editing is off until "+            + "you choose which one to keep."+    }++    /// The prefix every one of a kind's work-page identifiers is built from:+    /// `work-detail-character…` and `work-detail-place…`.+    static func workDetailIdentifier(_ kind: RecordKind, _ suffix: String = "") -> String {+        "work-detail-\(noun(kind))\(suffix)"+    }+}

diff --git a/Asterism/Asterism/Views/WorkDetailView.swift b/Asterism/Asterism/Views/WorkDetailView.swiftindex 5c46ccc..61a4d1b 100644--- a/Asterism/Asterism/Views/WorkDetailView.swift+++ b/Asterism/Asterism/Views/WorkDetailView.swift@@ -1,4 +1,6 @@ import AsterismCore+// For `ProposalKey`, which names a held row for the coordinator's decisions.+import AsterismIntelligence import ConstellationKit import SwiftUI @@ -68,10 +70,18 @@ struct WorkDetailView: View {     /// Which character's detail card is open under the cast pills; nil folds     /// every quote away.     @State private var expandedCharacterID: UUID?+    /// The same, for the Places section (`place-extraction` Req 4.1). Its own+    /// selection rather than one shared with the cast: the two sections sit one+    /// above the other, and opening a place would otherwise fold a character's+    /// card the reader was still reading.+    @State private var expandedPlaceID: UUID?     /// Which character's editor **sheet** is open in the edit session — the     /// same one-at-a-time selection the inline editor card had, per mode, so     /// the two selections do not fight.     @State private var expandedEditCharacterID: UUID?+    /// The same for the Places card. Two bindings rather than one, so a sheet+    /// raised from one card cannot be handed a record id from the other.+    @State private var expandedEditPlaceID: UUID?     /// Which order the spine is read in. `@State` and not stored (Q3): Newest is     /// the reading default and every open of the screen starts there.     @State private var sortOrder: WorkDetailModel.ChapterSortOrder = .newest@@ -201,12 +211,13 @@ struct WorkDetailView: View {     /// what it is part of and related to, who is in it, and what can be done to     /// the record itself.     ///-    /// Seven sections, three of which carry a `ConstellationSectionHeader` and-    /// four of which are captioned cards naming themselves — the shape the+    /// Eight sections, three of which carry a `ConstellationSectionHeader` and+    /// five of which are captioned cards naming themselves — the shape the     /// design canvas settled on (`specs/work-creators/decision_log.md`, the-    /// edit-screen decision). The Work URL and the URL-identity controls have-    /// no sections of their own any more: the field is a row of the Work card-    /// and the two controls are the first rows of Manage.+    /// edit-screen decision), with Places joining the collections at+    /// `place-extraction` Req 3.2. The Work URL and the URL-identity controls+    /// have no sections of their own any more: the field is a row of the Work+    /// card and the two controls are the first rows of Manage.     ///     /// Named rather than written inline in `workContent` because the two mode     /// branches together defeated the type checker once the series and link@@ -219,6 +230,7 @@ struct WorkDetailView: View {         editCreditsSection         editSeriesSection         editCharactersSection+        editPlacesSection         manageSection     } @@ -281,6 +293,7 @@ struct WorkDetailView: View {         seriesSection         openLastNotedSection         charactersSection+        placesSection         relatedWorksSection         chapterSection     }@@ -314,7 +327,7 @@ struct WorkDetailView: View {     private func workList(_ work: WorkSnapshot) -> some View {         List {             if model.isReadOnly { duplicateReviewSection }-            tornCharactersSection+            tornRecordsSection             proposalsIndicatorSection              if model.isEditing {@@ -369,7 +382,9 @@ struct WorkDetailView: View {                 editingCredit: $editingCredit))         .modifier(             WorkCharacterPresentations(-                model: model, editingCharacter: $expandedEditCharacterID))+                model: model,+                editingCharacter: $expandedEditCharacterID,+                editingPlace: $expandedEditPlaceID))         .markdownExportShare(             model: exportModel, sheetIdentifier: "work-detail-export-share-sheet")         // Req 7.1's two dispositions plus cancel. `presenting:` hands the@@ -1509,6 +1524,7 @@ struct WorkDetailView: View {                     // Each session starts folded; last session's open editor is                     // not this session's intent.                     expandedEditCharacterID = nil+                    expandedEditPlaceID = nil                     model.beginEditing()                     // Req 7.1's vocabulary, for the chips on each link card.                     // Read on entering the editor rather than on every open of@@ -1529,21 +1545,26 @@ struct WorkDetailView: View {         }     } -    // MARK: - Characters (`character-extraction` Reqs 2.1, 5.1–5.3, 1.11)+    // MARK: - Characters and places (`character-extraction` Reqs 2.1, 5.1–5.3,+    // 1.11; `place-extraction` Reqs 4.1–4.3) -    /// Req 6.5: torn characters are disclosed the way torn works are — in the+    /// Req 6.5: torn records are disclosed the way torn works are — in the     /// same top slot, wearing the same amber border, routing to the same sheet.-    /// A torn character is otherwise only visible as a label deep in the-    /// characters section, which is not a disclosure the reader will meet.+    /// A torn record is otherwise only visible as a label deep in its own+    /// section, which is not a disclosure the reader will meet.+    ///+    /// One card for both collections (`place-extraction` Req 5.3): the sentence+    /// names whichever kinds are torn, because two amber cards stacked would+    /// read as two problems where the reader has one route.     @ViewBuilder-    private var tornCharactersSection: some View {-        let torn = model.characters.filter(\.isTorn)+    private var tornRecordsSection: some View {+        let torn = model.characters.filter(\.isTorn) + model.places.filter(\.isTorn)         if !torn.isEmpty {             Section {                 VStack(alignment: .leading, spacing: 8) {                     Text(torn.count == 1                         ? "\(torn[0].name) arrived more than once and the copies differ."-                        : "\(torn.count) characters arrived more than once and their copies differ.")+                        : "\(torn.count) \(Self.tornNoun(torn)) arrived more than once and their copies differ.")                         .font(.callout)                         .foregroundStyle(AsterismColors.primaryText)                         .accessibilityIdentifier("work-detail-torn-characters-notice")@@ -1564,6 +1585,14 @@ struct WorkDetailView: View {         }     } +    /// What to call a mixed set of torn records: the collection where they are+    /// all of one kind, and the neutral word where they are not.+    private static func tornNoun(_ torn: [WorkRecordPresentation]) -> String {+        let kinds = Set(torn.map(\.kind))+        guard let only = kinds.first, kinds.count == 1 else { return "records" }+        return RecordKindPresentation.collection(only).lowercased()+    }+     /// Req 2.1's indicator, in the top slot the torn-work card already owns and     /// wearing the same amber border: held proposals are the other thing on this     /// screen that is waiting for a decision.@@ -1582,8 +1611,14 @@ struct WorkDetailView: View {            extraction.hasProposals(for: work.id) {             Section {                 VStack(alignment: .leading, spacing: 8) {+                    // `place-extraction` Req 2.1: one indicator for both kinds,+                    // counting every held row. The noun drops "character" —+                    // the sheet it opens decides places too, and a count+                    // labelled "character suggestions" that opened a list with+                    // places in it would be the screen lying about its own+                    // button.                     Label(-                        "\(Pluralisation.count(extraction.held(for: work.id).count, "character suggestion", "character suggestions")) from your notes",+                        "\(Pluralisation.count(extraction.held(for: work.id).count, "suggestion", "suggestions")) from your notes",                         systemImage: "sparkles")                         .font(.callout)                         .foregroundStyle(AsterismColors.primaryText)@@ -1614,26 +1649,58 @@ struct WorkDetailView: View {     private var charactersSection: some View {         if !model.characters.isEmpty || offersManualPass {             Section {-                if !model.characters.isEmpty {-                    // The cast as a wrapping pill grid — the quotes stay folded-                    // until a name is asked for. `.plain` on every pill, not the-                    // default style: sibling buttons in one List row bleed their-                    // hit areas into each other otherwise.-                    FlowLayout(spacing: 8) {-                        ForEach(model.characters) { character in-                            characterPill(character)-                        }-                    }-                    .frame(maxWidth: .infinity, alignment: .leading)-                    .constellationListRow()-                }-                if let expanded = model.characters.first(where: { $0.id == expandedCharacterID }) {-                    characterDetailCard(expanded)-                }+                recordCollection(model.characters, expanded: $expandedCharacterID)                 manualPassRow             } header: {-                ConstellationSectionHeader("Characters", accent: .violet)+                ConstellationSectionHeader(+                    RecordKindPresentation.collection(.character), accent: .violet)+            }+        }+    }++    /// `place-extraction` Req 4.1: the same composition as the cast, directly+    /// after it. A work with no places shows no section at all — the reader who+    /// has kept none is not shown an empty box telling them so, and the shared+    /// proposals indicator above is the only place-related element such a work+    /// carries.+    ///+    /// The manual-pass trigger stays in the Characters section: one pass+    /// produces both kinds, so a second trigger here would be a second button+    /// for one action.+    @ViewBuilder+    private var placesSection: some View {+        if !model.places.isEmpty {+            Section {+                recordCollection(model.places, expanded: $expandedPlaceID)+            } header: {+                ConstellationSectionHeader(+                    RecordKindPresentation.collection(.place), accent: .violet)+            }+        }+    }++    /// One collection's pills and the one open detail card under them, shared+    /// by both sections and told apart only by the kind each record carries+    /// (design §Views: a place surface mirrors the character one).+    @ViewBuilder+    private func recordCollection(+        _ records: [WorkRecordPresentation], expanded: Binding<UUID?>+    ) -> some View {+        if !records.isEmpty {+            // The collection as a wrapping pill grid — the quotes stay folded+            // until a name is asked for. `.plain` on every pill, not the+            // default style: sibling buttons in one List row bleed their hit+            // areas into each other otherwise.+            FlowLayout(spacing: 8) {+                ForEach(records) { record in+                    recordPill(record, expanded: expanded)+                }             }+            .frame(maxWidth: .infinity, alignment: .leading)+            .constellationListRow()+        }+        if let open = records.first(where: { $0.id == expanded.wrappedValue }) {+            recordDetailCard(open)         }     } @@ -1697,25 +1764,27 @@ struct WorkDetailView: View {             "\(link.linkType), \(link.displayTitle)")     } -    /// One name in the cast. The identifier sits on the button — a leaf-    /// element, so nothing inside is masked and the pill count is the cast-    /// count.-    private func characterPill(_ character: WorkCharacterPresentation) -> some View {-        let isExpanded = expandedCharacterID == character.id+    /// One name in a collection. The identifier sits on the button — a leaf+    /// element, so nothing inside is masked and the pill count is the+    /// collection's count.+    private func recordPill(+        _ record: WorkRecordPresentation, expanded: Binding<UUID?>+    ) -> some View {+        let isExpanded = expanded.wrappedValue == record.id         return Button {             withAnimation(.snappy) {-                expandedCharacterID = isExpanded ? nil : character.id+                expanded.wrappedValue = isExpanded ? nil : record.id             }         } label: {             HStack(spacing: 5) {-                Text(character.name)-                if character.isTorn {+                Text(record.name)+                if record.isTorn {                     // Req 6.5: disclosed where the reader meets it; the full                     // sentence is on the detail card.                     Image(systemName: "exclamationmark.circle")                         .foregroundStyle(AsterismColors.amberText)                 }-                Text("\(character.facts.count)")+                Text("\(record.facts.count)")                     .foregroundStyle(AsterismColors.secondaryText)                 Image(systemName: "chevron.down")                     .font(.caption2)@@ -1726,38 +1795,41 @@ struct WorkDetailView: View {             .constellationPill(isExpanded ? .selectedTypeTag : .typeTag)         }         .buttonStyle(.plain)-        .accessibilityIdentifier("work-detail-character")-        .accessibilityLabel("\(character.name), \(character.facts.count) facts")+        .accessibilityIdentifier(RecordKindPresentation.workDetailIdentifier(record.kind))+        .accessibilityLabel("\(record.name), \(record.facts.count) facts")     } -    /// The one expanded character: the name and its aliases, the note, then the+    /// The one expanded record: the name and its aliases, the note, then the     /// facts on the same gutter the spine uses — everything the old always-open     /// row showed, on request and laid out to be read.-    private func characterDetailCard(_ character: WorkCharacterPresentation) -> some View {-        VStack(alignment: .leading, spacing: 10) {+    private func recordDetailCard(_ record: WorkRecordPresentation) -> some View {+        let kind = record.kind+        return VStack(alignment: .leading, spacing: 10) {             // Q14: the aliases wrap beside the name as `.count` chips, the same             // recipe the editor's alias chips already use. "Also Nightjar, Jay"             // was a sentence about match keys; these are the keys.             FlowLayout(spacing: 8) {-                Text(character.name)+                Text(record.name)                     .font(AsterismTypography.serifHeading)-                ForEach(character.aliases, id: \.self) { alias in+                ForEach(record.aliases, id: \.self) { alias in                     Text(alias)                         .constellationPill(.count)-                        .accessibilityIdentifier("work-detail-character-alias-chip")+                        .accessibilityIdentifier(+                            RecordKindPresentation.workDetailIdentifier(kind, "-alias-chip"))                 }-                if character.isTorn {+                if record.isTorn {                     // Req 6.5: resolved where every torn record is.                     Label("Differing copies", systemImage: "exclamationmark.circle")                         .font(.caption)                         .foregroundStyle(AsterismColors.amberText)-                        .accessibilityIdentifier("work-detail-character-torn")+                        .accessibilityIdentifier(+                            RecordKindPresentation.workDetailIdentifier(kind, "-torn"))                 }             }             .frame(maxWidth: .infinity, alignment: .leading) -            if !character.note.isEmpty {-                Text(character.note)+            if !record.note.isEmpty {+                Text(record.note)                     .font(.subheadline)                     .foregroundStyle(AsterismColors.noteText)                     .lineSpacing(4)@@ -1765,12 +1837,12 @@ struct WorkDetailView: View {                     .frame(maxWidth: .infinity, alignment: .leading)             } -            if !character.facts.isEmpty {+            if !record.facts.isEmpty {                 Rectangle()                     .fill(AsterismColors.cardBorder)                     .frame(height: 1)-                ForEach(character.facts) { fact in-                    characterFactRow(fact)+                ForEach(record.facts) { fact in+                    recordFactRow(fact, kind: kind)                 }             }         }@@ -1787,9 +1859,9 @@ struct WorkDetailView: View {     /// The citation moves into the gutter (Q10): where the cited note has a     /// chapter key it is the number the spine draws, so the fact says which     /// chapter it came from without a caption to read (Q12).-    private func characterFactRow(_ fact: WorkCharacterFactRow) -> some View {+    private func recordFactRow(_ fact: WorkRecordFactRow, kind: RecordKind) -> some View {         HStack(alignment: .top, spacing: 8) {-            citationGutter(fact)+            citationGutter(fact, kind: kind)             VStack(alignment: .leading, spacing: 2) {                 Text(fact.statement)                     .font(.subheadline)@@ -1803,7 +1875,9 @@ struct WorkDetailView: View {                     // others carry no identifier rather than an empty one.                     if fact.isDangling {                         captionText-                            .accessibilityIdentifier("work-detail-character-citation-dangling")+                            .accessibilityIdentifier(+                                RecordKindPresentation.workDetailIdentifier(+                                    kind, "-citation-dangling"))                     } else {                         captionText                     }@@ -1817,13 +1891,13 @@ struct WorkDetailView: View {         // (`docs/agent-notes/testing.md`). `.contain` keeps the row findable as         // a group while its children keep their own identifiers.         .accessibilityElement(children: .contain)-        .accessibilityIdentifier("work-detail-character-fact")+        .accessibilityIdentifier(RecordKindPresentation.workDetailIdentifier(kind, "-fact"))     }      /// The gutter beside a fact: a link to the note it came from, or a dash     /// where there is no note to open.     @ViewBuilder-    private func citationGutter(_ fact: WorkCharacterFactRow) -> some View {+    private func citationGutter(_ fact: WorkRecordFactRow, kind: RecordKind) -> some View {         if let entryID = fact.citedEntryID {             if let onSelectEntry {                 Button { onSelectEntry(entryID) } label: {@@ -1838,7 +1912,8 @@ struct WorkDetailView: View {                         .contentShape(Rectangle())                 }                 .buttonStyle(.plain)-                .accessibilityIdentifier("work-detail-character-citation")+                .accessibilityIdentifier(+                    RecordKindPresentation.workDetailIdentifier(kind, "-citation"))                 .accessibilityLabel("Open \(citationName(fact))")             } else {                 // A host with no entry route — the Merge screen's embedded copy,@@ -1864,7 +1939,7 @@ struct WorkDetailView: View {     /// number it — the gutter has to read as a link either way, and a bare "Ch."     /// would read as a number that failed to render.     @ViewBuilder-    private func citationGlyph(_ fact: WorkCharacterFactRow) -> some View {+    private func citationGlyph(_ fact: WorkRecordFactRow) -> some View {         if let label = fact.citedChapterKey?.label {             Text(label)                 .font(AsterismTypography.mono.weight(.semibold))@@ -1879,7 +1954,7 @@ struct WorkDetailView: View {      /// Q12: a live citation with a key says everything in its gutter. Without a     /// key the arrow alone would not, so the note's title or date stays.-    private func citationCaption(_ fact: WorkCharacterFactRow) -> String? {+    private func citationCaption(_ fact: WorkRecordFactRow) -> String? {         if fact.citedEntryID != nil {             return fact.citedChapterKey == nil ? citationName(fact) : nil         }@@ -1892,7 +1967,7 @@ struct WorkDetailView: View {     /// its own title where that says more than the work's name — and the capture     /// date otherwise, because on the work's own page a link labelled with the     /// work's title identifies nothing.-    private func citationName(_ fact: WorkCharacterFactRow) -> String {+    private func citationName(_ fact: WorkRecordFactRow) -> String {         fact.citationTitle ?? citationDateLabel(fact)     } @@ -1905,7 +1980,7 @@ struct WorkDetailView: View {     /// The citation's label of last resort: the note's capture date. Always the     /// abbreviated date — unlike the spine's "Today", it is read in a sentence     /// ("Noted 12 Aug"), where the relative form would not scan.-    private func citationDateLabel(_ fact: WorkCharacterFactRow) -> String {+    private func citationDateLabel(_ fact: WorkRecordFactRow) -> String {         guard let date = fact.citationDate else { return "this note" }         return "Noted \(date.formatted(date: .abbreviated, time: .omitted))"     }@@ -1929,7 +2004,11 @@ struct WorkDetailView: View {                 Button {                     Task { await runManualPass(workID: work.id) }                 } label: {-                    Label("Look for characters", systemImage: "sparkles")+                    // `place-extraction` Req 2.1: one pass, both kinds. The+                    // label says so, because a trigger reading "Look for+                    // characters" that returns places is the same lie the+                    // indicator's noun was.+                    Label("Look for characters and places", systemImage: "sparkles")                         .frame(maxWidth: .infinity, minHeight: AsterismLayout.minHitTarget)                 }                 .buttonStyle(.constellationSecondary)@@ -1941,7 +2020,7 @@ struct WorkDetailView: View {                             .controlSize(.small)                             .padding(.trailing, 18)                             .accessibilityIdentifier("work-detail-extract-busy")-                            .accessibilityLabel("Looking for characters")+                            .accessibilityLabel("Looking for characters and places")                     }                 } @@ -1985,57 +2064,71 @@ struct WorkDetailView: View {     /// selection is the same `expandedEditCharacterID` it always was; it now     /// says which sheet is up rather than which card is unfolded.     private var editCharactersSection: some View {-        Section {+        editRecordsSection(of: .character, opening: $expandedEditCharacterID)+    }++    /// `place-extraction` Req 3.2's Places card, directly after Characters and+    /// on its terms: the same compact lines, the same footer button, the same+    /// sheet. Fifth captioned card, fourth collection.+    private var editPlacesSection: some View {+        editRecordsSection(of: .place, opening: $expandedEditPlaceID)+    }++    /// One collection's card. The lines come from the model's `editLines(of:)`,+    /// which reads the **drafts**, so a staged conversion moves a line from one+    /// card to the other the moment the reader taps.+    private func editRecordsSection(+        of kind: RecordKind, opening editing: Binding<UUID?>+    ) -> some View {+        let lines = model.editLines(of: kind)+        return Section {             VStack(alignment: .leading, spacing: 12) {-                if !model.characters.isEmpty || !newCharacterIDs.isEmpty {+                if !lines.isEmpty {                     VStack(alignment: .leading, spacing: 6) {-                        ForEach(model.characters) { character in-                            if let draft = model.characterDraft(for: character.id) {-                                editCharacterLine(-                                    id: character.id, draft: draft, isTorn: character.isTorn)-                            }-                        }-                        ForEach(newCharacterIDs, id: \.self) { id in-                            if let draft = model.characterDraft(for: id) {-                                editCharacterLine(id: id, draft: draft, isTorn: false)-                            }+                        ForEach(lines) { line in+                            editRecordLine(line, kind: kind, opening: editing)                         }                     }                 } -                ConstellationFooterButton(title: "Add a character") {+                ConstellationFooterButton(title: RecordKindPresentation.addTitle(kind)) {                     // The new draft opens for naming; a line labelled "New                     // character" with nothing open would be a dead end.-                    expandedEditCharacterID = model.addCharacter(named: "")+                    editing.wrappedValue = model.addRecord(kind, named: "")                 }                 .disabled(model.isReadOnly)-                .accessibilityIdentifier("work-detail-add-character")+                .accessibilityIdentifier("work-detail-add-\(RecordKindPresentation.noun(kind))")             }-            .constellationCaptionedCard("Characters")+            .constellationCaptionedCard(RecordKindPresentation.collection(kind))         }     } -    /// One name in the edit session's cast, with what its draft holds. Labelled-    /// from the draft, so a rename shows on the line as it is typed.-    private func editCharacterLine(id: UUID, draft: CharacterDraft, isTorn: Bool) -> some View {-        let name = draft.name.isEmpty ? "New character" : draft.name-        let counts = Self.characterCounts(draft)-        return ConstellationLineRow(name: name, detail: counts, showsAttention: isTorn) {-            expandedEditCharacterID = id+    /// One name in the edit session's collection, with what its draft holds.+    /// Labelled from the draft, so a rename shows on the line as it is typed.+    private func editRecordLine(+        _ line: WorkDetailModel.RecordEditLine, kind: RecordKind, opening editing: Binding<UUID?>+    ) -> some View {+        let name = line.draft.name.isEmpty+            ? RecordKindPresentation.newRecordTitle(kind) : line.draft.name+        let counts = Self.recordCounts(line.draft)+        return ConstellationLineRow(name: name, detail: counts, showsAttention: line.isTorn) {+            editing.wrappedValue = line.id         }-        .accessibilityIdentifier("work-detail-character-line-\(id.uuidString)")+        .accessibilityIdentifier(+            RecordKindPresentation.workDetailIdentifier(kind, "-line-\(line.id.uuidString)"))         .accessibilityLabel(-            ([name, counts].compactMap { $0 } + (isTorn ? ["differing copies"] : []))+            ([name, counts].compactMap { $0 } + (line.isTorn ? ["differing copies"] : []))                 .joined(separator: ", "))-        .accessibilityHint("Opens this character's name, aliases and facts")+        .accessibilityHint(+            "Opens this \(RecordKindPresentation.noun(kind))'s name, aliases and facts")     }      /// "2 aliases · 3 facts" — the two things a draft holds that the line can-    /// count, and nothing at all for a character that holds neither.+    /// count, and nothing at all for a record that holds neither.     ///-    /// New presentation of data the editor already carried: `CharacterDraft` has+    /// New presentation of data the editor already carried: `RecordDraft` has     /// always had both, and the pill showed only the name.-    private static func characterCounts(_ draft: CharacterDraft) -> String? {+    private static func recordCounts(_ draft: RecordDraft) -> String? {         var parts: [String] = []         if !draft.aliases.isEmpty {             parts.append(Pluralisation.count(draft.aliases.count, "alias", "aliases"))@@ -2046,13 +2139,6 @@ struct WorkDetailView: View {         return parts.isEmpty ? nil : parts.joined(separator: " · ")     } -    /// The characters this session created, in the order the reader added them.-    ///-    /// The model's order, not a sort of the draft dictionary's keys: a UUID is-    /// random, so sorting by `uuidString` dropped each new row into an arbitrary-    /// place in the list and re-ordered the ones already there.-    private var newCharacterIDs: [UUID] { model.createdCharacterIDs }-      private func openReview(workID: UUID) {         guard let extraction else { return }@@ -2065,13 +2151,30 @@ struct WorkDetailView: View {             workID: workID,             proposals: extraction.held(for: workID),             characters: model.characters,+            places: model.places,             captureOrder: model.captureOrder,             library: model.libraryForReview,-            onDecision: { nameKey in extraction.discard(nameKey: nameKey, for: workID) },-            // Q66: a `.reRouted` refusal names the character the row really+            // Req 2.2: the reclassify preview's suppression and accepted-fact+            // input. Read through the closure rather than captured, so a pass+            // or a reconcile that lands while the sheet is open is what the+            // next preview sees.+            extractionContext: { extraction.context(for: workID) },+            // Q56/Q77: the **gated** field — a skip that wrote a name-key+            // suppression under both kinds also discards the row of that name+            // key held under the other one, and nothing else does.+            onDecision: { key, kinds in+                extraction.discard(key, for: workID, nameKeySuppressedKinds: kinds)+            },+            // Q66: a `.reRouted` refusal names the record the row really             // resolves onto, and the coordinator is where the held row lives.-            onReRoute: { nameKey, target in-                extraction.retarget(nameKey: nameKey, for: workID, to: target)+            onReRoute: { key, target in+                extraction.retarget(key, for: workID, to: target)+            },+            // Req 2.2/Q28: the reader's kind and the target the preview+            // resolved go onto the held row, so the choice survives the sheet+            // closing and a later settlement's merge keeps it (Q69).+            onReclassify: { key, kind, target in+                extraction.reclassify(key, for: workID, to: kind, target: target)             },             // Q110: reconcile before answering. The refusal disclosure promises             // the list below is up to date, and this is the pass that makes it@@ -2328,14 +2431,17 @@ private struct WorkCreditPresentations: ViewModifier {     } } -/// The character editor a cast line opens (`character-extraction` Req 5.3).+/// The record editor a collection line opens (`character-extraction` Req 5.3,+/// `place-extraction` Req 3.2). /// /// Bound to the same `expandedEditCharacterID` the inline editor card used, so /// "Add a character" and a finished combine still open the character they mean-/// by assigning to it.+/// by assigning to it — and to a second binding for Places, so a sheet raised+/// from one card is never handed the other card's id. private struct WorkCharacterPresentations: ViewModifier {     let model: WorkDetailModel     @Binding var editingCharacter: UUID?+    @Binding var editingPlace: UUID?      func body(content: Content) -> some View {         content@@ -2344,12 +2450,22 @@ private struct WorkCharacterPresentations: ViewModifier {                     get: { editingCharacter.map { PresentedID(id: $0) } },                     set: { editingCharacter = $0?.id })             ) { presented in-                CharacterEditorView(model: model, characterID: presented.id) { target in+                CharacterEditorView(model: model, recordID: presented.id, kind: .character) {+                    target in                     // The source's line just left the cast; the target's editor                     // takes its place so the reader sees where everything went.                     editingCharacter = target                 }             }+            .sheet(+                item: Binding(+                    get: { editingPlace.map { PresentedID(id: $0) } },+                    set: { editingPlace = $0?.id })+            ) { presented in+                CharacterEditorView(model: model, recordID: presented.id, kind: .place) { target in+                    editingPlace = target+                }+            }     } } 

diff --git a/Asterism/AsterismTests/CharacterExtractionCoordinatorTests.swift b/Asterism/AsterismTests/CharacterExtractionCoordinatorTests.swiftindex 66f23d8..5e43a8f 100644--- a/Asterism/AsterismTests/CharacterExtractionCoordinatorTests.swift+++ b/Asterism/AsterismTests/CharacterExtractionCoordinatorTests.swift@@ -71,12 +71,14 @@ struct CharacterExtractionCoordinatorTests {         recency: TimeInterval = 0,         notes: String = "Ada carried the lantern.",         covered: Bool = false,-        characters: [CharacterMatchTarget] = [],-        acceptedFacts: Set<CharacterFactIdentity> = [],-        suppressions: CharacterSuppressionIndex = .empty-    ) -> CharacterExtractionCandidate {+        characters: [MatchTarget] = [],+        places: [MatchTarget] = [],+        acceptedFacts: Set<RecordFactIdentity> = [],+        suppressions: SuppressionIndex = .empty,+        placeSuppressions: SuppressionIndex = .empty+    ) -> ExtractionCandidate {         let fingerprint = CharacterCoverageFingerprint.of(notes)-        return CharacterExtractionCandidate(+        return ExtractionCandidate(             workID: workID,             displayTitle: title,             recency: Date(timeIntervalSince1970: recency),@@ -85,19 +87,71 @@ struct CharacterExtractionCoordinatorTests {                     ref: .genericNotes, text: notes, fingerprint: fingerprint,                     coveredFingerprint: covered ? fingerprint : nil)             ],-            characters: characters,-            acceptedFactIdentities: acceptedFacts,-            suppressions: suppressions)+            records: [.character: characters, .place: places],+            acceptedFacts: [.character: acceptedFacts],+            suppressions: [.character: suppressions, .place: placeSuppressions])+    }++    /// One work whose two sources both name "Bay", so the pass can hold a+    /// dual-kind row from one response and a plain place row from the other —+    /// the shape Q56's cross-kind discard is about.+    private nonisolated static func bayCandidate(+        workID: UUID, entryID: UUID+    ) -> ExtractionCandidate {+        let notes = "Bay smiles at the harbour."+        let chapter = "The Bay is grim in winter."+        return ExtractionCandidate(+            workID: workID,+            displayTitle: "A Work",+            recency: Date(timeIntervalSince1970: 0),+            sources: [+                CharacterExtractionSource(+                    ref: .genericNotes, text: notes,+                    fingerprint: CharacterCoverageFingerprint.of(notes),+                    coveredFingerprint: nil),+                CharacterExtractionSource(+                    ref: .entry(entryID), text: chapter,+                    fingerprint: CharacterCoverageFingerprint.of(chapter),+                    coveredFingerprint: nil),+            ],+            records: [:],+            acceptedFacts: [:],+            suppressions: [:])     } +    /// The generic notes return "Bay" under both kinds — Req 1.5's union row,+    /// displayed as a character (Q20) — and the chapter returns it as a place+    /// only, which is its own row under its own key.+    private nonisolated static let bayScript: [StubCharacterExtractionModelClient.ScriptedResult] = [+        .success(ExtractionResult(+            characters: [+                ExtractedCharacter(+                    name: "Bay",+                    facts: [ExtractedFact(statement: "Bay smiles.", quote: "Bay smiles")])+            ],+            places: [+                ExtractedPlace(+                    name: "Bay",+                    facts: [ExtractedPlaceFact(statement: "The bay holds a harbour.",+                                               quote: "at the harbour")])+            ])),+        .success(ExtractionResult(+            places: [+                ExtractedPlace(+                    name: "Bay",+                    facts: [ExtractedPlaceFact(statement: "The Bay is grim.",+                                               quote: "The Bay is grim")])+            ])),+    ]+     /// One work with **two** uncovered sources, so a stop taken between them is     /// observable at all: the per-work guard cannot see it.     private nonisolated static func twoSourceCandidate(         workID: UUID, entryID: UUID, recency: TimeInterval = 0-    ) -> CharacterExtractionCandidate {+    ) -> ExtractionCandidate {         let notes = "Ada carried the lantern."         let chapter = "Brede followed."-        return CharacterExtractionCandidate(+        return ExtractionCandidate(             workID: workID,             displayTitle: "A Work",             recency: Date(timeIntervalSince1970: recency),@@ -111,30 +165,33 @@ struct CharacterExtractionCoordinatorTests {                     fingerprint: CharacterCoverageFingerprint.of(chapter),                     coveredFingerprint: nil),             ],-            characters: [],-            acceptedFactIdentities: [],-            suppressions: .empty)+            records: [:],+            acceptedFacts: [:],+            suppressions: [:])     }      private nonisolated static func result(         _ name: String = "Ada", statement: String = "Ada carried a lantern.",-        quote: String = "Ada carried the lantern"+        quote: String = "Ada carried the lantern",+        places: [ExtractedPlace] = []     ) -> ExtractionResult {-        ExtractionResult(characters: [-            ExtractedCharacter(-                name: name, facts: [ExtractedFact(statement: statement, quote: quote)])-        ])+        ExtractionResult(+            characters: [+                ExtractedCharacter(+                    name: name, facts: [ExtractedFact(statement: statement, quote: quote)])+            ],+            places: places)     }      private func makeSUT(-        candidates: [CharacterExtractionCandidate] = [],+        candidates: [ExtractionCandidate] = [],         availability: ModelAvailability = .available,         stub: StubCharacterExtractionModelClient = StubCharacterExtractionModelClient(             result: CharacterExtractionCoordinatorTests.result())     ) -> (CharacterExtractionCoordinator, MockLibraryProvider, MutableAvailabilityClient,           StubEnvironment) {         let mock = MockLibraryProvider()-        mock.characterExtractionCandidatesResult = .success(candidates)+        mock.extractionCandidatesResult = .success(candidates)         let client = MutableAvailabilityClient(availability, inner: stub)         let environment = StubEnvironment()         // A lane of its own: `ModelLane.shared` is app-wide by design, and a@@ -204,16 +261,23 @@ struct CharacterExtractionCoordinatorTests {         #expect(mock.lastCharacterExtractionWorkIDs == .some(nil))     } +    /// One request per source for **both** kinds (Q4): the combined answer+    /// changes what comes back, never what is sent (Req 1.1).     @Test("A request carries the work's title and one source's text, and nothing else")     func requestCarriesOnlyTheSource() async {         let workID = UUID()+        let notes = "Ada carried the lantern up to Kestrel Head."         let recorder = StubCharacterExtractionModelClient.Recorder()-        let stub = StubCharacterExtractionModelClient(result: Self.result(), recorder: recorder)+        let stub = StubCharacterExtractionModelClient(+            result: Self.result(places: [+                ExtractedPlace(+                    name: "Kestrel Head",+                    facts: [ExtractedPlaceFact(statement: "The lantern went up to Kestrel Head.",+                                               quote: "up to Kestrel Head")])+            ]),+            recorder: recorder)         let (coordinator, _, _, _) = makeSUT(-            candidates: [-                Self.candidate(-                    workID: workID, title: "Lanterns", notes: "Ada carried the lantern.")-            ],+            candidates: [Self.candidate(workID: workID, title: "Lanterns", notes: notes)],             stub: stub)          await coordinator.activationSweep()@@ -221,8 +285,10 @@ struct CharacterExtractionCoordinatorTests {         #expect(recorder.callCount == 1)         let request = recorder.recordedSources.first         #expect(request?.workTitle == "Lanterns")-        #expect(request?.text == "Ada carried the lantern.")+        #expect(request?.text == notes)         #expect(request?.source == .genericNotes)+        // Both kinds came back through the one request.+        #expect(Set(coordinator.held(for: workID).map(\.kind)) == [.character, .place])     }      @Test("A covered source is not re-processed")@@ -309,7 +375,7 @@ struct CharacterExtractionCoordinatorTests {         #expect(!coordinator.isModelAvailable)         #expect(recorder.callCount == 0)         // Req 1.2's read bound is not even paid for.-        #expect(mock.characterExtractionCandidatesCallCount == 0)+        #expect(mock.extractionCandidatesCallCount == 0)          // Availability is transient, so it is re-read every activation.         client.availabilityResult = .available@@ -338,6 +404,27 @@ struct CharacterExtractionCoordinatorTests {         #expect(advance?.sources.first?.fingerprint == CharacterCoverageFingerprint.of(notes))     } +    /// Req 1.4: coverage is one record per revision over **both** arrays, so+    /// "produced none" means neither kind survived grounding — not that the+    /// characters array was empty.+    @Test("A source whose characters and places both ground to nothing covers at pass time")+    func producedNoneCoversWhenBothArraysGroundAway() async {+        let workID = UUID()+        let notes = "Nothing here names anyone."+        // Neither name appears in the source, so grounding drops both (Req 1.2).+        let stub = StubCharacterExtractionModelClient(result: ExtractionResult(+            characters: [ExtractedCharacter(name: "Ada", facts: [])],+            places: [ExtractedPlace(name: "Kestrel Head", facts: [])]))+        let (coordinator, mock, _, _) = makeSUT(+            candidates: [Self.candidate(workID: workID, notes: notes)], stub: stub)++        await coordinator.activationSweep()++        #expect(coordinator.held(for: workID).isEmpty)+        #expect(mock.advancedCoverage.count == 1)+        #expect(mock.advancedCoverage.first?.sources.map(\.ref) == [.genericNotes])+    }+     @Test("A source with shown proposals is left for the decision to cover")     func shownProposalsAreNotCoveredAtPassTime() async {         let (coordinator, mock, _, _) = makeSUT(candidates: [Self.candidate()])@@ -352,14 +439,14 @@ struct CharacterExtractionCoordinatorTests {         let workID = UUID()         // The only fact the model offers is one the reader already accepted, so         // the row empties and there is nothing left to decide (Req 1.7).-        let accepted = CharacterFactIdentity(+        let accepted = RecordFactIdentity(             nameKey: "ada", source: .genericNotes, quote: "Ada carried the lantern")         let (coordinator, mock, _, _) = makeSUT(             candidates: [                 Self.candidate(                     workID: workID,                     characters: [-                        CharacterMatchTarget(+                        MatchTarget(                             id: UUID(), currentNameKey: "ada", retainedKey: "ada",                             aliasKeys: [], isTorn: false)                     ],@@ -414,7 +501,7 @@ struct CharacterExtractionCoordinatorTests {     @Test("A failed candidate read skips the activation in silence")     func failedCandidateReadSkipsSweep() async {         let (coordinator, mock, _, _) = makeSUT()-        mock.characterExtractionCandidatesResult = .failure(MockLibraryProvider.MockError.notConfigured)+        mock.extractionCandidatesResult = .failure(MockLibraryProvider.MockError.notConfigured)          await coordinator.activationSweep() @@ -430,7 +517,7 @@ struct CharacterExtractionCoordinatorTests {         await coordinator.activationSweep()         #expect(coordinator.hasProposals(for: workID)) -        mock.characterExtractionCandidatesResult = .success([])+        mock.extractionCandidatesResult = .success([])         await coordinator.reconcile()          #expect(!coordinator.hasProposals(for: workID))@@ -443,7 +530,7 @@ struct CharacterExtractionCoordinatorTests {         await coordinator.activationSweep()         #expect(coordinator.hasProposals(for: workID)) -        mock.characterExtractionCandidatesResult = .success([+        mock.extractionCandidatesResult = .success([             Self.candidate(workID: workID, notes: "Ada carried the lantern, and a rope.")         ])         await coordinator.reconcile()@@ -468,7 +555,7 @@ struct CharacterExtractionCoordinatorTests {          await coordinator.reconcile() -        #expect(mock.characterExtractionCandidatesCallCount == 0)+        #expect(mock.extractionCandidatesCallCount == 0)     }      // MARK: - Lifecycle@@ -479,10 +566,16 @@ struct CharacterExtractionCoordinatorTests {         let (coordinator, _, _, _) = makeSUT(candidates: [Self.candidate(workID: workID)])         await coordinator.activationSweep()         #expect(coordinator.hasProposals(for: workID))+        #expect(coordinator.context(for: workID) != nil, "the sweep retained the read")          coordinator.memoryWarning()          #expect(!coordinator.hasProposals(for: workID))+        // The cached candidate reads go with the held rows: they are the other+        // half of what the warning is about, and a context left behind would+        // feed the reclassify preview from a library state nothing is holding+        // any more.+        #expect(coordinator.context(for: workID) == nil)     }      /// Q110: the stop signal is checked **per source**, not per work.@@ -542,7 +635,7 @@ struct CharacterExtractionCoordinatorTests {             candidates: [                 Self.candidate(                     workID: workID,-                    suppressions: CharacterSuppressionIndex(+                    suppressions: SuppressionIndex(                         candidateKeys: ["ada"], factIdentities: []))             ]) @@ -554,14 +647,14 @@ struct CharacterExtractionCoordinatorTests {     @Test("A manual pass still refuses to re-propose an accepted fact")     func manualPassDedupsAcceptedFacts() async {         let workID = UUID()-        let accepted = CharacterFactIdentity(+        let accepted = RecordFactIdentity(             nameKey: "ada", source: .genericNotes, quote: "Ada carried the lantern")         let (coordinator, _, _, _) = makeSUT(             candidates: [                 Self.candidate(                     workID: workID,                     characters: [-                        CharacterMatchTarget(+                        MatchTarget(                             id: UUID(), currentNameKey: "ada", retainedKey: "ada",                             aliasKeys: [], isTorn: false)                     ],@@ -664,6 +757,50 @@ struct CharacterExtractionCoordinatorTests {         #expect(coordinator.manualOutcome(for: workID) == nil)     } +    // MARK: - The retained candidate read (Req 2.2's preview input)++    /// The reclassify preview needs the suppressed identities of the kind it is+    /// moving *to*, and the only read that has them is the candidate read the+    /// pass already made. So the coordinator keeps the last one per work rather+    /// than the sheet paying for a second fetch on a toggle.+    @Test("A pass retains the work's candidate read, and reconcile refreshes it")+    func contextRetainedByAPassAndRefreshedByReconcile() async {+        let workID = UUID()+        let placeKey = RecordNameKey.normalize("Kestrel Head")+        let (coordinator, mock, _, _) = makeSUT(candidates: [Self.candidate(workID: workID)])++        await coordinator.activationSweep()++        let afterPass = coordinator.context(for: workID)+        #expect(afterPass != nil)+        #expect(afterPass?.suppressedNameKeys(of: .place).isEmpty == true)++        // A place skip that arrived by sync since the pass shows up on the next+        // reconcile — the preview reads the store's answer, not the pass's.+        mock.extractionCandidatesResult = .success([+            Self.candidate(+                workID: workID,+                placeSuppressions: SuppressionIndex(+                    candidateKeys: [placeKey], factIdentities: []))+        ])+        await coordinator.reconcile()++        #expect(coordinator.context(for: workID)?.suppressedNameKeys(of: .place) == [placeKey])+    }++    @Test("A work the library no longer offers loses its retained read")+    func contextDroppedWithTheWork() async {+        let workID = UUID()+        let (coordinator, mock, _, _) = makeSUT(candidates: [Self.candidate(workID: workID)])+        await coordinator.activationSweep()+        #expect(coordinator.context(for: workID) != nil)++        mock.extractionCandidatesResult = .success([])+        await coordinator.reconcile()++        #expect(coordinator.context(for: workID) == nil)+    }+     // MARK: - Decisions      @Test("Discarding a decided row leaves its siblings held")@@ -689,8 +826,107 @@ struct CharacterExtractionCoordinatorTests {         await coordinator.activationSweep()         #expect(coordinator.held(for: workID).count == 2) -        coordinator.discard(nameKey: "ada", for: workID)+        coordinator.discard(ProposalKey(kind: .character, nameKey: "ada"), for: workID)          #expect(coordinator.held(for: workID).map(\.nameKey) == ["brede"])     }++    /// The row's identity is its **assembled** kind and name key (Q28), so a+    /// place row and a character row of one name are two rows and one discard+    /// reaches exactly one of them.+    @Test("A single-kind decision leaves the same name's row of the other kind held")+    func discardIsPerKindByDefault() async {+        let workID = UUID(), entryID = UUID()+        let (coordinator, _, _, _) = makeSUT(+            candidates: [Self.bayCandidate(workID: workID, entryID: entryID)],+            stub: StubCharacterExtractionModelClient(results: Self.bayScript))++        await coordinator.activationSweep()+        #expect(coordinator.held(for: workID).map(\.kind) == [.character, .place])++        coordinator.discard(ProposalKey(kind: .character, nameKey: "bay"), for: workID,+                            nameKeySuppressedKinds: [.character])++        #expect(coordinator.held(for: workID).map(\.kind) == [.place])+    }++    /// Q56: the reader skipped "Bay" under both kinds, and a "Bay — Place" row+    /// another source produced would contradict the suppression the commit just+    /// wrote. So a decision that suppressed the name key under both kinds+    /// sweeps every held row of that key, whichever kind it displays.+    @Test("A skip that suppressed both kinds discards every held row of that name key")+    func dualKindSkipDiscardsAcrossKinds() async {+        let workID = UUID(), entryID = UUID()+        let (coordinator, _, _, _) = makeSUT(+            candidates: [Self.bayCandidate(workID: workID, entryID: entryID)],+            stub: StubCharacterExtractionModelClient(results: Self.bayScript))++        await coordinator.activationSweep()+        let dual = coordinator.held(for: workID).first { $0.kind == .character }+        #expect(dual?.returnedKinds == [.character, .place], "the union row Q56 is about")++        coordinator.discard(ProposalKey(kind: .character, nameKey: "bay"), for: workID,+                            nameKeySuppressedKinds: [.character, .place])++        #expect(coordinator.held(for: workID).isEmpty)+    }++    /// Req 2.4 and Q77, from the other end: the same union row **accepted**.+    ///+    /// `suppressedKinds` names both kinds here too — it answers "which kinds+    /// would a name-key suppression be written under", not "which were written"+    /// — so a sweep taking that field would drop the "Bay — Place" row another+    /// source produced, on a decision that suppressed nothing. The gated+    /// accessor is empty, and the place row stays held.+    @Test("An accepted union row sweeps nothing across kinds")+    func acceptedDualKindRowKeepsTheOtherKindsRow() async {+        let workID = UUID(), entryID = UUID()+        let (coordinator, _, _, _) = makeSUT(+            candidates: [Self.bayCandidate(workID: workID, entryID: entryID)],+            stub: StubCharacterExtractionModelClient(results: Self.bayScript))++        await coordinator.activationSweep()+        let dual = coordinator.held(for: workID).first { $0.kind == .character }+        let request = dual?.decisionRequest(workID: workID, action: .accept)+        #expect(request?.suppressedKinds == [.character, .place], "the ungated field, for contrast")+        #expect(request?.nameKeySuppressedKinds == [], "an accept writes no name-key suppression")++        coordinator.discard(ProposalKey(kind: .character, nameKey: "bay"), for: workID,+                            nameKeySuppressedKinds: request?.nameKeySuppressedKinds ?? [])++        #expect(coordinator.held(for: workID).map(\.kind) == [.place])+    }++    @Test("A re-routed decision re-points the row it was about, by key")+    func retargetAppliesToTheRowsKey() async {+        let workID = UUID()+        let recordID = UUID()+        let (coordinator, _, _, _) = makeSUT(candidates: [Self.candidate(workID: workID)])+        await coordinator.activationSweep()++        coordinator.retarget(ProposalKey(kind: .character, nameKey: "ada"), for: workID,+                             to: recordID)++        #expect(coordinator.held(for: workID).first?.target == .existing(recordID))+    }++    /// Req 2.2: the reader's choice lives with the held row for the app run, so+    /// the sheet can be closed and reopened without losing it.+    @Test("Reclassifying moves the kind the row displays and the target it was previewed against")+    func reclassifyReachesTheLedger() async {+        let workID = UUID()+        let placeID = UUID()+        let (coordinator, _, _, _) = makeSUT(candidates: [Self.candidate(workID: workID)])+        await coordinator.activationSweep()++        coordinator.reclassify(ProposalKey(kind: .character, nameKey: "ada"), for: workID,+                               to: .place, target: placeID)++        let row = coordinator.held(for: workID).first+        // Q28: the identity stays where the pass put it, so the reader's ticks+        // and strikes stay attached to the row they were made on.+        #expect(row?.kind == .character)+        #expect(row?.displayedKind == .place)+        #expect(row?.target == .existing(placeID))+    } }

diff --git a/Asterism/AsterismTests/CharacterReviewModelTests.swift b/Asterism/AsterismTests/CharacterReviewModelTests.swiftindex ccfa483..656eb34 100644--- a/Asterism/AsterismTests/CharacterReviewModelTests.swift+++ b/Asterism/AsterismTests/CharacterReviewModelTests.swift@@ -5,18 +5,27 @@ import Testing @testable import Asterism  /// Tests for `CharacterReviewModel`: the sheet that turns held proposals into-/// decisions (Reqs 2.1, 2.2, 2.5, 2.7).+/// decisions (Reqs 2.1, 2.2, 2.5, 2.7 of `character-extraction`, Reqs 2.1–2.3+/// of `place-extraction`). /// /// The commit itself is the repository's and is covered against a real store in /// `CharacterExtractionRepositoryTests`. What is pinned here is what the sheet-/// *sends* — the displayed keys, the struck aliases, the unticked facts — and-/// what it does with what comes back.+/// *sends* — the displayed keys, the struck aliases, the unticked facts, the+/// kind and the previewed target — and what it does with what comes back. @Suite("CharacterReviewModel") @MainActor struct CharacterReviewModelTests {      // MARK: - Fixtures +    /// The row identity every identifier is built from: the **assembled** kind+    /// and the name key (Q28).+    private nonisolated static func rowID(+        _ nameKey: String, _ kind: RecordKind = .character+    ) -> String {+        ProposalKey(kind: kind, nameKey: nameKey).rowID+    }+     private nonisolated static func fact(         _ statement: String, quote: String, key: String = "ada",         source: SourceRef = .genericNotes@@ -25,42 +34,70 @@ struct CharacterReviewModelTests {     }      private nonisolated static func candidate(-        name: String = "Ada", key: String = "ada", aliases: [String] = [],+        name: String = "Ada", key: String = "ada", kind: RecordKind = .character,+        aliases: [String] = [],         facts: [GroundedFact]? = nil,-        target: ExtractionProposal.Target = .newCharacter,-        revisions: [SourceRef: String] = [.genericNotes: "fp-1"]+        target: ExtractionProposal.Target = .newRecord,+        revisions: [SourceRef: String] = [.genericNotes: "fp-1"],+        displayedKind: RecordKind? = nil,+        returnedKinds: Set<RecordKind>? = nil     ) -> ExtractionProposal {         ExtractionProposal(-            name: name, nameKey: key, proposedAliases: aliases, target: target,+            name: name, nameKey: key, kind: kind, proposedAliases: aliases, target: target,             facts: facts ?? [fact("Ada keeps the light.", quote: "Ada keeps the light", key: key)],-            citedRevisions: revisions)+            citedRevisions: revisions,+            displayedKind: displayedKind, returnedKinds: returnedKinds)     } -    private nonisolated static func character(-        id: UUID, name: String = "Ada", facts: [CharacterFact] = []-    ) -> WorkCharacterPresentation {-        WorkCharacterPresentation(-            id: id, name: name, note: "", aliases: [],-            nameKey: CharacterNameKey.normalize(name),+    /// One record the work already has, of either kind — what a bundle is drawn+    /// against and what a reclassify preview resolves onto.+    private nonisolated static func record(+        id: UUID, kind: RecordKind = .character, name: String = "Ada",+        nameKey: String? = nil, aliases: [String] = [], facts: [RecordFact] = []+    ) -> WorkRecordPresentation {+        WorkRecordPresentation(+            id: id, kind: kind, name: name, note: "", aliases: aliases,+            nameKey: nameKey ?? RecordNameKey.normalize(name),             facts: facts.map {-                WorkCharacterFactRow(-                    id: $0.quote, statement: $0.statement, quote: $0.quote, source: $0.source,+                WorkRecordFactRow(+                    id: $0.displayRowID, statement: $0.statement, quote: $0.quote,+                    source: $0.source,                     citedEntryID: nil, citationTitle: nil, isDangling: false, fact: $0)             },             isTorn: false, rowCount: 1,-            editBasis: CharacterEditBasis(-                characterID: id, name: name, note: "", aliases: [], facts: facts))+            editBasis: RecordEditBasis(+                kind: kind, recordID: id, name: name, note: "", aliases: aliases, facts: facts))+    }++    private nonisolated static func character(+        id: UUID, name: String = "Ada", facts: [RecordFact] = []+    ) -> WorkRecordPresentation {+        record(id: id, kind: .character, name: name, facts: facts)+    }++    /// The suppression half of a candidate read, as the coordinator retains it.+    private nonisolated static func context(+        suppressedFacts: [RecordKind: Set<RecordFactIdentity>] = [:]+    ) -> CharacterExtractionContext {+        CharacterExtractionContext(+            records: [:], acceptedFacts: [:], suppressedNameKeys: [:],+            suppressedFacts: suppressedFacts)     }      private func makeSUT(         workID: UUID = UUID(),         proposals: [ExtractionProposal] = [CharacterReviewModelTests.candidate()],-        characters: [WorkCharacterPresentation] = []+        characters: [WorkRecordPresentation] = [],+        places: [WorkRecordPresentation] = [],+        context: CharacterExtractionContext? = nil     ) -> (CharacterReviewModel, MockLibraryProvider) {         let mock = MockLibraryProvider()         let model = CharacterReviewModel(-            workID: workID, proposals: proposals, characters: characters, library: mock,-            onDecision: { _ in }, onReRoute: { _, _ in }, refresh: { [] })+            workID: workID, proposals: proposals, characters: characters, places: places,+            library: mock,+            extractionContext: { context },+            onDecision: { _, _ in }, onReRoute: { _, _ in }, onReclassify: { _, _, _ in },+            refresh: { [] })         return (model, mock)     } @@ -80,9 +117,9 @@ struct CharacterReviewModelTests {     private nonisolated static func extractionCandidate(         workID: UUID,         notes: String = "Ada keeps the light.",-        characters: [CharacterMatchTarget] = []-    ) -> CharacterExtractionCandidate {-        CharacterExtractionCandidate(+        characters: [MatchTarget] = []+    ) -> ExtractionCandidate {+        ExtractionCandidate(             workID: workID,             displayTitle: "The Lamp Room",             recency: Date(timeIntervalSince1970: 0),@@ -92,19 +129,20 @@ struct CharacterReviewModelTests {                     fingerprint: CharacterCoverageFingerprint.of(notes),                     coveredFingerprint: nil)             ],-            characters: characters,-            acceptedFactIdentities: [],-            suppressions: .empty)+            records: [.character: characters],+            acceptedFacts: [:],+            suppressions: [:])     }      private nonisolated static func workPresentation(-        workID: UUID, characters: [WorkCharacterPresentation]+        workID: UUID, characters: [WorkRecordPresentation],+        places: [WorkRecordPresentation] = []     ) -> WorkDetailPresentation {         let base = TestFixtures.makeWorkDetail(work: TestFixtures.makeWork(id: workID))         return WorkDetailPresentation(             work: base.work, pulse: base.pulse,             lastNotedURLString: base.lastNotedURLString, chapterRows: base.chapterRows,-            characters: characters)+            characters: characters, places: places)     }      /// A coordinator holding what a real sweep assembled over `library`.@@ -148,7 +186,7 @@ struct CharacterReviewModelTests {     @Test("A bundle row shows the target character's existing facts beside the proposals")     func bundleShowsExistingFacts() {         let characterID = UUID()-        let existing = CharacterFact(+        let existing = RecordFact(             statement: "Ada arrived by sea.", quote: "arrived by sea", nameKey: "ada",             source: .genericNotes)         let (model, _) = makeSUT(@@ -178,6 +216,335 @@ struct CharacterReviewModelTests {         #expect(model.rows.first?.aliases.first?.isStruck == false)     } +    // MARK: - Both kinds in one list (Req 2.1)++    @Test("A row carries the kind it is displayed under and the kind it was assembled under")+    func rowsCarryTheirKind() {+        let (model, _) = makeSUT(+            proposals: [+                Self.candidate(name: "Ada", key: "ada"),+                Self.candidate(name: "Kestrel Head", key: "kestrel head", kind: .place),+            ])++        #expect(model.rows.map(\.kind) == [.character, .place])+        #expect(model.rows.map(\.originalKind) == [.character, .place])+        // The row's identity is the proposal key's, so two rows of one name key+        // under two kinds are two rows (Q28).+        #expect(model.rows.map(\.id) == ["character:ada", "place:kestrel head"])+    }++    @Test("A union row discloses that the name was proposed under both kinds")+    func dualKindRowDiscloses() {+        let (model, _) = makeSUT(+            proposals: [+                Self.candidate(name: "Selkie", key: "selkie", returnedKinds: [.character, .place]),+                Self.candidate(name: "Ada", key: "ada"),+            ])++        #expect(model.rows.first?.isDualKind == true)+        #expect(model.rows.last?.isDualKind == false)+    }++    @Test("Only candidates and reclassification-produced bundles offer the kind control")+    func onlyCandidatesOfferTheKindControl() {+        let characterID = UUID()+        let (model, _) = makeSUT(+            proposals: [+                Self.candidate(name: "Ada", key: "ada"),+                Self.candidate(name: "Brede", key: "brede", target: .existing(characterID)),+            ],+            characters: [Self.character(id: characterID, name: "Brede")])++        #expect(model.rows.first?.canReclassify == true, "a candidate can be reclassified")+        #expect(+            model.rows.last?.canReclassify == false,+            "Req 2.2: a bundle the pass assembled offers no kind control")+    }++    // MARK: - The reclassify preview (Reqs 2.2, 2.3, Q24)++    @Test("Reclassifying onto a matching record redraws the row as a bundle at once")+    func reclassifyRedrawsACandidateAsABundle() {+        let placeID = UUID()+        let existing = RecordFact(+            statement: "The head faces north.", quote: "faces north", nameKey: "kestrel head",+            source: .genericNotes)+        let (model, _) = makeSUT(+            proposals: [+                Self.candidate(+                    name: "Kestrel Head", key: "kestrel head",+                    facts: [+                        Self.fact(+                            "Kestrel Head is windswept.", quote: "windswept", key: "kestrel head")+                    ])+            ],+            places: [+                Self.record(id: placeID, kind: .place, name: "Kestrel Head", facts: [existing])+            ])++        model.reclassify(Self.rowID("kestrel head"), to: .place)++        let row = model.rows.first+        #expect(row?.kind == .place)+        #expect(row?.originalKind == .character)+        #expect(row?.isBundle == true)+        #expect(row?.targetID == placeID)+        #expect(row?.existingFacts.map(\.statement) == ["The head faces north."])+        #expect(row?.canReclassify == true, "Req 2.2: the control stays on a bundle it produced")+    }++    @Test("Reclassifying back redraws the bundle as the candidate it was")+    func reclassifyBackRedrawsTheCandidate() {+        let placeID = UUID()+        let (model, _) = makeSUT(+            proposals: [Self.candidate(name: "Kestrel Head", key: "kestrel head")],+            places: [Self.record(id: placeID, kind: .place, name: "Kestrel Head")])++        model.reclassify(Self.rowID("kestrel head"), to: .place)+        model.reclassify(Self.rowID("kestrel head"), to: .character)++        let row = model.rows.first+        #expect(row?.kind == .character)+        #expect(row?.isBundle == false)+        #expect(row?.targetID == nil)+        #expect(row?.proposedFacts.count == 1, "the facts came back with the kind")+    }++    @Test("Reclassifying re-keys the facts and dedups them against the destination's own")+    func reclassifyReKeysAndDedupsAgainstThePresentations() async {+        let placeID = UUID()+        // The place already holds this fact, under **its** retained key. The+        // proposal's copy is keyed to the character candidate's key, so only a+        // re-key before the dedup can recognise the two as one fact (Q79).+        let accepted = RecordFact(+            statement: "Kestrel Head is windswept.", quote: "windswept", nameKey: "kh-retained",+            source: .genericNotes)+        let entryID = UUID()+        let (model, mock) = makeSUT(+            proposals: [+                Self.candidate(+                    name: "Kestrel Head", key: "kestrel head",+                    facts: [+                        Self.fact(+                            "Kestrel Head is windswept.", quote: "windswept", key: "kestrel head"),+                        Self.fact(+                            "Gulls nest there.", quote: "Gulls nest", key: "kestrel head",+                            source: .entry(entryID)),+                    ],+                    revisions: [.genericNotes: "fp-1", .entry(entryID): "fp-2"])+            ],+            places: [+                Self.record(+                    id: placeID, kind: .place, name: "Kestrel Head", nameKey: "kh-retained",+                    facts: [accepted])+            ])++        model.reclassify(Self.rowID("kestrel head"), to: .place)++        #expect(+            model.rows.first?.proposedFacts.map(\.statement) == ["Gulls nest there."],+            "the accepted copy deduped away under the destination")++        await model.accept(Self.rowID("kestrel head"))++        let request = mock.committedDecisions.first+        #expect(request?.kind == .place)+        #expect(request?.displayedTargetID == placeID)+        #expect(+            request?.facts.map(\.nameKey) == ["kh-retained"],+            "Q59: the request is built from the projection, not from the held row")+    }++    @Test("Reclassifying drops facts the destination kind's suppressions cover")+    func reclassifyDropsSuppressedFacts() {+        let suppressed = RecordFactIdentity(+            nameKey: "kestrel head", source: .genericNotes, quote: "windswept")+        let (model, _) = makeSUT(+            proposals: [+                Self.candidate(+                    name: "Kestrel Head", key: "kestrel head",+                    facts: [+                        Self.fact(+                            "Kestrel Head is windswept.", quote: "windswept", key: "kestrel head")+                    ])+            ],+            context: Self.context(suppressedFacts: [.place: [suppressed]]))++        model.reclassify(Self.rowID("kestrel head"), to: .place)++        #expect(model.rows.first?.proposedFacts.isEmpty == true)+        #expect(+            model.rows.count == 1,+            "Req 2.2: a row never leaves an open list on a toggle")+        #expect(+            model.rows.first?.canAccept == false,+            "nothing is left to accept; the skip still decides it")+    }++    /// Req 2.2/Q31 read the other way: only a row whose facts *deduped away*+    /// under the destination loses its Keep. A candidate the model returned with+    /// no facts at all (Req 1.2) had none to lose — it is the common shape for a+    /// place named in passing — and disabling Keep there would leave Skip as the+    /// only decision on the very name the reader had just re-filed.+    @Test("A reclassified name-only candidate can still be kept")+    func reclassifiedNameOnlyCandidateCanBeKept() {+        let (model, _) = makeSUT(+            proposals: [Self.candidate(name: "Kestrel Head", key: "kestrel head", facts: [])])++        model.reclassify(Self.rowID("kestrel head"), to: .place)++        let row = model.rows.first+        #expect(row?.kind == .place)+        #expect(row?.proposedFacts.isEmpty == true)+        #expect(row?.canAccept == true, "nothing deduped away, so the name is still there to keep")+    }++    @Test("A reclassified candidate carrying only aliases can still be kept")+    func reclassifiedAliasOnlyCandidateCanBeKept() {+        let (model, _) = makeSUT(+            proposals: [+                Self.candidate(+                    name: "Kestrel Head", key: "kestrel head", aliases: ["The Head"], facts: [])+            ])++        model.reclassify(Self.rowID("kestrel head"), to: .place)++        let row = model.rows.first+        #expect(row?.aliases.map(\.name) == ["The Head"])+        #expect(row?.canAccept == true, "the aliases are Q92's, and an accept installs them")+    }++    /// Q36's survival predicate counts a new alias as content worth keeping, so+    /// a reclassified row whose facts all deduped away but which still carries+    /// an unstruck alias has something to keep. Disabling Keep there threw that+    /// alias away and left Skip as the only decision on the row.+    @Test("A reclassified row whose facts deduped away keeps its Keep for its aliases")+    func reclassifiedRowWithAliasesAndNoFactsCanBeKept() {+        let suppressed = RecordFactIdentity(+            nameKey: "kestrel head", source: .genericNotes, quote: "windswept")+        let (model, _) = makeSUT(+            proposals: [+                Self.candidate(+                    name: "Kestrel Head", key: "kestrel head", aliases: ["The Head"],+                    facts: [+                        Self.fact(+                            "Kestrel Head is windswept.", quote: "windswept", key: "kestrel head")+                    ])+            ],+            context: Self.context(suppressedFacts: [.place: [suppressed]]))++        model.reclassify(Self.rowID("kestrel head"), to: .place)++        let row = model.rows.first+        #expect(row?.kind == .place)+        #expect(+            row?.proposedFacts.isEmpty == true,+            "the fact deduped away under the destination kind")+        #expect(row?.aliases.map(\.name) == ["The Head"])+        #expect(row?.canAccept == true, "the unstruck alias is still content worth keeping")+    }++    @Test("A character suppression does not reach the character row it was toggled from")+    func suppressionsAreReadPerKind() {+        let suppressed = RecordFactIdentity(+            nameKey: "kestrel head", source: .genericNotes, quote: "windswept")+        let (model, _) = makeSUT(+            proposals: [+                Self.candidate(+                    name: "Kestrel Head", key: "kestrel head",+                    facts: [+                        Self.fact(+                            "Kestrel Head is windswept.", quote: "windswept", key: "kestrel head")+                    ])+            ],+            context: Self.context(suppressedFacts: [.character: [suppressed]]))++        model.reclassify(Self.rowID("kestrel head"), to: .place)++        #expect(+            model.rows.first?.proposedFacts.count == 1,+            "Req 1.6: the place half is filtered against place suppressions only")+    }++    @Test("Ticks and strikes survive a reclassify")+    func ticksAndStrikesSurviveAReclassify() {+        let (model, _) = makeSUT(+            proposals: [+                Self.candidate(+                    name: "Kestrel Head", key: "kestrel head", aliases: ["The Head"],+                    facts: [+                        Self.fact(+                            "Kestrel Head is windswept.", quote: "windswept", key: "kestrel head"),+                        Self.fact("Gulls nest there.", quote: "Gulls nest", key: "kestrel head"),+                    ])+            ])+        let rowID = Self.rowID("kestrel head")+        guard let factID = model.rows.first?.proposedFacts.first?.id else {+            Issue.record("Expected a proposed fact")+            return+        }++        model.setTicked(false, factID: factID, in: rowID)+        model.setStruck(true, alias: "The Head", in: rowID)+        model.reclassify(rowID, to: .place)++        let row = model.rows.first+        #expect(row?.proposedFacts.first { $0.id == factID }?.isTicked == false)+        #expect(row?.aliases.first?.isStruck == true)+    }++    @Test("Reclassifying tells the coordinator the kind and the previewed target")+    func reclassifyTellsTheCoordinator() {+        let placeID = UUID()+        nonisolated(unsafe) var reclassified: [(ProposalKey, RecordKind, UUID?)] = []+        let model = CharacterReviewModel(+            workID: UUID(),+            proposals: [Self.candidate(name: "Kestrel Head", key: "kestrel head")],+            characters: [],+            places: [Self.record(id: placeID, kind: .place, name: "Kestrel Head")],+            library: MockLibraryProvider(),+            extractionContext: { nil },+            onDecision: { _, _ in }, onReRoute: { _, _ in },+            onReclassify: { reclassified.append(($0, $1, $2)) },+            refresh: { [] })++        model.reclassify(Self.rowID("kestrel head"), to: .place)++        #expect(reclassified.count == 1)+        #expect(reclassified.first?.0 == ProposalKey(kind: .character, nameKey: "kestrel head"))+        #expect(reclassified.first?.1 == .place)+        #expect(reclassified.first?.2 == placeID)+    }++    // MARK: - The cross-kind hint (Q41)++    @Test("A place row whose name a character already answers to says so")+    func placeRowHintsAtAnExistingCharacter() {+        let (model, _) = makeSUT(+            proposals: [Self.candidate(name: "Selkie", key: "selkie", kind: .place)],+            characters: [Self.record(id: UUID(), kind: .character, name: "Selkie")])++        #expect(model.rows.first?.crossKindHint == "You already have a character with this name")+    }++    @Test("A character row whose name a place already answers to says so")+    func characterRowHintsAtAnExistingPlace() {+        let (model, _) = makeSUT(+            proposals: [Self.candidate(name: "Selkie", key: "selkie")],+            places: [Self.record(id: UUID(), kind: .place, name: "Selkie")])++        #expect(model.rows.first?.crossKindHint == "You already have a place with this name")+    }++    @Test("No hint where the other kind holds nothing of that name")+    func noHintWithoutACrossKindMatch() {+        let (model, _) = makeSUT(+            proposals: [Self.candidate(name: "Selkie", key: "selkie")],+            places: [Self.record(id: UUID(), kind: .place, name: "Kestrel Head")])++        #expect(model.rows.first?.crossKindHint == nil)+    }+     // MARK: - Snapshot at open (Req 2.7)      @Test("A later sweep's proposals do not change the open sheet")@@ -187,7 +554,9 @@ struct CharacterReviewModelTests {         nonisolated(unsafe) var latest = [Self.candidate(name: "Ada", key: "ada")]         let model = CharacterReviewModel(             workID: workID, proposals: latest, characters: [], library: mock,-            onDecision: { _ in }, onReRoute: { _, _ in }, refresh: { latest })+            extractionContext: { nil },+            onDecision: { _, _ in }, onReRoute: { _, _ in }, onReclassify: { _, _, _ in },+            refresh: { latest })          latest.append(Self.candidate(name: "Brede", key: "brede")) @@ -224,7 +593,9 @@ struct CharacterReviewModelTests {             workID: UUID(), proposals: [proposal], characters: [],             captureOrder: [capturedFirst: 0, capturedSecond: 1],             library: MockLibraryProvider(),-            onDecision: { _ in }, onReRoute: { _, _ in }, refresh: { [] })+            extractionContext: { nil },+            onDecision: { _, _ in }, onReRoute: { _, _ in }, onReclassify: { _, _, _ in },+            refresh: { [] })          #expect(             model.rows.first?.proposedFacts.map(\.source)@@ -250,7 +621,7 @@ struct CharacterReviewModelTests {          await model.accept(row.id) -        let request = mock.committedCharacterDecisions.first+        let request = mock.committedDecisions.first         #expect(request?.facts.isEmpty == true)         #expect(request?.untickedFacts.count == 1)     }@@ -267,7 +638,7 @@ struct CharacterReviewModelTests {         model.setStruck(true, alias: "Nightjar", in: row.id)         await model.accept(row.id) -        let request = mock.committedCharacterDecisions.first+        let request = mock.committedDecisions.first         #expect(request?.proposedAliases == ["Lampkeeper"])         #expect(request?.displayedKeys == ["ada", "lampkeeper"])     }@@ -284,7 +655,7 @@ struct CharacterReviewModelTests {         model.setStruck(true, alias: "Nightjar", in: row.id)         await model.skip(row.id) -        let request = mock.committedCharacterDecisions.first+        let request = mock.committedDecisions.first         #expect(request?.action == .skip)         // The struck alias's key is not among them (Q92).         #expect(request?.displayedKeys == ["ada"])@@ -309,7 +680,7 @@ struct CharacterReviewModelTests {          await model.accept(row.id) -        let sources = mock.committedCharacterDecisions.first?.completedSources ?? []+        let sources = mock.committedDecisions.first?.completedSources ?? []         #expect(sources.count == 2)         #expect(Set(sources.map(\.ref)) == Set([.genericNotes, .entry(entryID)]))     }@@ -318,26 +689,55 @@ struct CharacterReviewModelTests {      @Test("A committed decision leaves the sheet and tells the coordinator which row it was")     func commitReportsTheDecidedRow() async {-        nonisolated(unsafe) var decided: [String] = []+        nonisolated(unsafe) var decided: [ProposalKey] = []         let mock = MockLibraryProvider()         let model = CharacterReviewModel(             workID: UUID(),             proposals: [Self.candidate(name: "Ada", key: "ada"),                         Self.candidate(name: "Brede", key: "brede")],             characters: [], library: mock,-            onDecision: { decided.append($0) }, onReRoute: { _, _ in }, refresh: { [] })+            extractionContext: { nil },+            onDecision: { key, _ in decided.append(key) }, onReRoute: { _, _ in },+            onReclassify: { _, _, _ in },+            refresh: { [] }) -        await model.accept("ada")+        await model.accept(Self.rowID("ada")) -        #expect(decided == ["ada"])+        #expect(decided == [ProposalKey(kind: .character, nameKey: "ada")])         #expect(model.rows.map(\.name) == ["Brede"])     } +    /// Q56/Q77: the coordinator's cross-kind sweep runs on the kinds the commit+    /// **wrote** a name-key suppression under, which is the gated reading — a+    /// candidate skip and nothing else.+    @Test("A skipped union row reports both suppressed kinds; an accepted one reports none")+    func skipOfAUnionRowReportsBothKinds() async {+        nonisolated(unsafe) var reported: [Set<RecordKind>] = []+        let mock = MockLibraryProvider()+        let model = CharacterReviewModel(+            workID: UUID(),+            proposals: [+                Self.candidate(name: "Selkie", key: "selkie", returnedKinds: [.character, .place]),+                Self.candidate(name: "Ada", key: "ada", returnedKinds: [.character, .place]),+            ],+            characters: [], library: mock,+            extractionContext: { nil },+            onDecision: { _, kinds in reported.append(kinds) }, onReRoute: { _, _ in },+            onReclassify: { _, _, _ in },+            refresh: { [] })++        await model.skip(Self.rowID("selkie"))+        await model.accept(Self.rowID("ada"))++        #expect(reported.first == [.character, .place])+        #expect(reported.last?.isEmpty == true, "Req 2.4: an accept never touches the other kind")+    }+     @Test("Deciding the last row empties the sheet")     func lastDecisionEmptiesTheSheet() async {         let (model, _) = makeSUT() -        await model.accept("ada")+        await model.accept(Self.rowID("ada"))          #expect(model.isEmpty)     }@@ -348,7 +748,7 @@ struct CharacterReviewModelTests {             proposals: [Self.candidate(name: "Ada", key: "ada"),                         Self.candidate(name: "Brede", key: "brede")]) -        await model.accept("ada")+        await model.accept(Self.rowID("ada"))         model.dismiss()          // Nothing was discarded on the way out: the coordinator still holds@@ -368,16 +768,16 @@ struct CharacterReviewModelTests {          // Hold the first commit in flight until the test releases it.         let (gate, release) = AsyncStream.makeStream(of: Void.self)-        mock.commitCharacterDecisionHold = { for await _ in gate {} }+        mock.commitDecisionHold = { for await _ in gate {} } -        let first = Task { await model.accept("ada") }-        while mock.committedCharacterDecisions.isEmpty { await Task.yield() }+        let first = Task { await model.accept(Self.rowID("ada")) }+        while mock.committedDecisions.isEmpty { await Task.yield() }         #expect(model.isSubmitting)          // The second tap commits nothing and decides nothing.-        await model.accept("brede")-        #expect(mock.committedCharacterDecisions.count == 1)-        #expect(model.rows.contains { $0.id == "brede" })+        await model.accept(Self.rowID("brede"))+        #expect(mock.committedDecisions.count == 1)+        #expect(model.rows.contains { $0.id == Self.rowID("brede") })          release.finish()         await first.value@@ -396,7 +796,7 @@ struct CharacterReviewModelTests {     func staleRefusalInvalidatesTheRow() async {         let workID = UUID()         let mock = MockLibraryProvider()-        mock.characterExtractionCandidatesResult = .success([+        mock.extractionCandidatesResult = .success([             Self.extractionCandidate(workID: workID)         ])         let coordinator = await sweptCoordinator(library: mock)@@ -405,23 +805,27 @@ struct CharacterReviewModelTests {         let model = CharacterReviewModel(             workID: workID, proposals: coordinator.held(for: workID), characters: [],             library: mock,-            onDecision: { coordinator.discard(nameKey: $0, for: workID) },+            extractionContext: { nil },+            onDecision: { key, kinds in+                coordinator.discard(key, for: workID, nameKeySuppressedKinds: kinds)+            },             onReRoute: { key, target in-                coordinator.retarget(nameKey: key, for: workID, to: target)+                coordinator.retarget(key, for: workID, to: target)             },+            onReclassify: { _, _, _ in },             refresh: {                 await coordinator.reconcile()                 return coordinator.held(for: workID)             })          // The note the proposal cites has been edited since it was assembled.-        mock.characterExtractionCandidatesResult = .success([+        mock.extractionCandidatesResult = .success([             Self.extractionCandidate(workID: workID, notes: "Ada keeps the light, and the door.")         ])         mock.workDetailResult = .success(Self.workPresentation(workID: workID, characters: []))-        mock.commitCharacterDecisionResult = .success(.refused(.staleSource(.genericNotes)))+        mock.commitDecisionResult = .success(.refused(.staleSource(.genericNotes))) -        await model.accept("ada")+        await model.accept(Self.rowID("ada"))          #expect(model.disclosure?.contains("changed") == true)         #expect(model.isEmpty, "the stale row is gone from the sheet")@@ -439,19 +843,19 @@ struct CharacterReviewModelTests {         // The work already has a character under a different key, so the sweep's         // proposal is assembled as a *candidate* — which is the state the         // re-route has to move.-        mock.characterExtractionCandidatesResult = .success([+        mock.extractionCandidatesResult = .success([             Self.extractionCandidate(                 workID: workID,                 characters: [-                    CharacterMatchTarget(+                    MatchTarget(                         id: characterID, currentNameKey: "ada vance", retainedKey: "ada vance",                         aliasKeys: [], isTorn: false)                 ])         ])         let coordinator = await sweptCoordinator(library: mock)-        #expect(coordinator.held(for: workID).first?.target == .newCharacter)+        #expect(coordinator.held(for: workID).first?.target == .newRecord) -        let existing = CharacterFact(+        let existing = RecordFact(             statement: "Ada arrived by sea.", quote: "arrived by sea", nameKey: "ada vance",             source: .genericNotes)         // The sheet's own snapshot has no characters in it: the resolving one may@@ -459,10 +863,14 @@ struct CharacterReviewModelTests {         let model = CharacterReviewModel(             workID: workID, proposals: coordinator.held(for: workID), characters: [],             library: mock,-            onDecision: { coordinator.discard(nameKey: $0, for: workID) },+            extractionContext: { nil },+            onDecision: { key, kinds in+                coordinator.discard(key, for: workID, nameKeySuppressedKinds: kinds)+            },             onReRoute: { key, target in-                coordinator.retarget(nameKey: key, for: workID, to: target)+                coordinator.retarget(key, for: workID, to: target)             },+            onReclassify: { _, _, _ in },             refresh: {                 await coordinator.reconcile()                 return coordinator.held(for: workID)@@ -473,9 +881,9 @@ struct CharacterReviewModelTests {                 characters: [                     Self.character(id: characterID, name: "Ada Vance", facts: [existing])                 ]))-        mock.commitCharacterDecisionResult = .success(.refused(.reRouted(to: characterID)))+        mock.commitDecisionResult = .success(.refused(.reRouted(to: characterID))) -        await model.accept("ada")+        await model.accept(Self.rowID("ada"))          #expect(model.disclosure != nil)         #expect(@@ -489,15 +897,131 @@ struct CharacterReviewModelTests {         #expect(row?.existingFacts.map(\.statement) == ["Ada arrived by sea."])     } +    /// Q24/Q59: a re-route refused under the **displayed** kind comes back as a+    /// bundle of that kind, drawn against the places the refresh re-read — the+    /// reclassified row must not be redrawn as the character candidate it was+    /// assembled as.+    @Test("A re-routed refusal after a reclassify refreshes as a bundle of the displayed kind")+    func reRoutedRefusalAfterReclassifyRefreshesAsAPlaceBundle() async {+        let workID = UUID(), placeID = UUID()+        let held = Self.candidate(name: "Kestrel Head", key: "kestrel head")+        nonisolated(unsafe) var latest = [held]+        let mock = MockLibraryProvider()+        let existing = RecordFact(+            statement: "The head faces north.", quote: "faces north", nameKey: "kestrel head",+            source: .genericNotes)+        let place = Self.record(+            id: placeID, kind: .place, name: "Kestrel Head", facts: [existing])+        let model = CharacterReviewModel(+            workID: workID, proposals: latest, characters: [], places: [], library: mock,+            extractionContext: { nil },+            onDecision: { _, _ in },+            onReRoute: { key, target in+                // What the coordinator does: the held row is re-pointed, keeping+                // the reader's displayed kind.+                latest = latest.map { proposal in+                    guard proposal.key == key else { return proposal }+                    var moved = proposal+                    moved.displayedKind = .place+                    moved.target = target.map { .existing($0) } ?? .newRecord+                    return moved+                }+            },+            onReclassify: { _, _, _ in },+            refresh: { latest })+        mock.workDetailResult = .success(+            Self.workPresentation(workID: workID, characters: [], places: [place]))+        mock.commitDecisionResult = .success(.refused(.reRouted(to: placeID)))++        model.reclassify(Self.rowID("kestrel head"), to: .place)+        await model.accept(Self.rowID("kestrel head"))++        let row = model.rows.first+        #expect(model.rows.count == 1)+        #expect(row?.kind == .place)+        #expect(row?.isBundle == true)+        #expect(row?.targetID == placeID)+        #expect(row?.existingFacts.map(\.statement) == ["The head faces north."])+    }++    /// Q69: the ledger's merge keeps the reader's kind and the **older** row's+    /// previewed target, because it cannot preview one itself. The sheet is+    /// where that target is replaced: the re-preview runs under the displayed+    /// kind over the merged content.+    @Test("A merged row is re-previewed under the reader's kind over the merged content")+    func mergedRowIsRePreviewedUnderTheReadersKind() async {+        let workID = UUID()+        let goneID = UUID(), placeID = UUID()+        let entryID = UUID()+        var ledger = CharacterExtractionLedger()+        let older = Self.candidate(+            name: "Kestrel Head", key: "kestrel head",+            facts: [+                Self.fact("Kestrel Head is windswept.", quote: "windswept", key: "kestrel head")+            ])+        let newer = Self.candidate(+            name: "Kestrel Head", key: "kestrel head",+            facts: [+                Self.fact(+                    "Gulls nest there.", quote: "Gulls nest", key: "kestrel head",+                    source: .entry(entryID))+            ],+            revisions: [.entry(entryID): "fp-2"])++        let first = ExtractionSourceKey(work: workID, source: .genericNotes)+        _ = ledger.start(+            first, fingerprint: "fp-1", pass: .manual, environment: ModelWorkEnvironment())+        ledger.settle(first, .proposals([older]), modelPhase: .zero)+        // The reader reclassified before the second source settled, and the+        // preview resolved onto a place that has since gone.+        ledger.reclassify(older.key, for: workID, to: .place, target: goneID)+        let second = ExtractionSourceKey(work: workID, source: .entry(entryID))+        _ = ledger.start(+            second, fingerprint: "fp-2", pass: .manual, environment: ModelWorkEnvironment())+        ledger.settle(second, .proposals([newer]), modelPhase: .zero)++        let merged = ledger.held(for: workID)+        #expect(merged.first?.displayedKind == .place, "the ledger kept the reader's kind")+        #expect(merged.first?.target == .existing(goneID), "and the older row's target")++        nonisolated(unsafe) var reclassified: [(ProposalKey, RecordKind, UUID?)] = []+        let model = CharacterReviewModel(+            workID: workID, proposals: merged, characters: [],+            places: [Self.record(id: placeID, kind: .place, name: "Kestrel Head")],+            library: MockLibraryProvider(),+            extractionContext: { nil },+            onDecision: { _, _ in }, onReRoute: { _, _ in },+            onReclassify: { reclassified.append(($0, $1, $2)) },+            refresh: { [] })++        let row = model.rows.first+        #expect(row?.kind == .place)+        #expect(+            row?.targetID == placeID,+            "Q69: the sheet re-previews the merged row and replaces the ledger's target")+        #expect(+            row?.proposedFacts.count == 2,+            "over the merged content — both sources' facts")+        // The other half of Q69: the held row is told, so the ledger's stale+        // target does not outlive the sheet. Without the write-back the next+        // reconcile judges the row against a place that has gone.+        #expect(reclassified.count == 1)+        #expect(reclassified.first?.0 == older.key)+        #expect(reclassified.first?.1 == .place)+        #expect(reclassified.first?.2 == placeID)+    }+     @Test("A torn refusal discloses and routes the reader to Check Library")     func tornRefusalRoutes() async {         let mock = MockLibraryProvider()-        mock.commitCharacterDecisionResult = .success(.refused(.torn(characterID: UUID())))+        mock.commitDecisionResult = .success(.refused(.torn(recordID: UUID())))         let model = CharacterReviewModel(             workID: UUID(), proposals: [Self.candidate()], characters: [], library: mock,-            onDecision: { _ in }, onReRoute: { _, _ in }, refresh: { [Self.candidate()] })+            extractionContext: { nil },+            onDecision: { _, _ in }, onReRoute: { _, _ in }, onReclassify: { _, _, _ in },+            refresh: { [Self.candidate()] }) -        await model.accept("ada")+        await model.accept(Self.rowID("ada"))          #expect(model.disclosure != nil)         #expect(model.routesToCheckLibrary)@@ -508,26 +1032,30 @@ struct CharacterReviewModelTests {     @Test("A torn work still takes a skip")     func tornWorkStillTakesASkip() async {         let mock = MockLibraryProvider()-        mock.commitCharacterDecisionResult = .success(.committed(characterID: nil))+        mock.commitDecisionResult = .success(.committed(recordID: nil))         let model = CharacterReviewModel(             workID: UUID(), proposals: [Self.candidate()], characters: [], library: mock,-            onDecision: { _ in }, onReRoute: { _, _ in }, refresh: { [] })+            extractionContext: { nil },+            onDecision: { _, _ in }, onReRoute: { _, _ in }, onReclassify: { _, _, _ in },+            refresh: { [] }) -        await model.skip("ada")+        await model.skip(Self.rowID("ada"))          #expect(model.isEmpty)-        #expect(mock.committedCharacterDecisions.first?.action == .skip)+        #expect(mock.committedDecisions.first?.action == .skip)     }      @Test("A vanished work closes the sheet")     func workGoneClosesTheSheet() async {         let mock = MockLibraryProvider()-        mock.commitCharacterDecisionResult = .success(.refused(.workGone))+        mock.commitDecisionResult = .success(.refused(.workGone))         let model = CharacterReviewModel(             workID: UUID(), proposals: [Self.candidate()], characters: [], library: mock,-            onDecision: { _ in }, onReRoute: { _, _ in }, refresh: { [] })+            extractionContext: { nil },+            onDecision: { _, _ in }, onReRoute: { _, _ in }, onReclassify: { _, _, _ in },+            refresh: { [] }) -        await model.accept("ada")+        await model.accept(Self.rowID("ada"))          #expect(model.isEmpty)     }@@ -535,12 +1063,14 @@ struct CharacterReviewModelTests {     @Test("A thrown commit keeps the row and says so")     func thrownCommitKeepsTheRow() async {         let mock = MockLibraryProvider()-        mock.commitCharacterDecisionResult = .failure(MockLibraryProvider.MockError.notConfigured)+        mock.commitDecisionResult = .failure(MockLibraryProvider.MockError.notConfigured)         let model = CharacterReviewModel(             workID: UUID(), proposals: [Self.candidate()], characters: [], library: mock,-            onDecision: { _ in }, onReRoute: { _, _ in }, refresh: { [Self.candidate()] })+            extractionContext: { nil },+            onDecision: { _, _ in }, onReRoute: { _, _ in }, onReclassify: { _, _, _ in },+            refresh: { [Self.candidate()] }) -        await model.accept("ada")+        await model.accept(Self.rowID("ada"))          #expect(model.disclosure != nil)         #expect(model.rows.count == 1)@@ -561,18 +1091,21 @@ struct CharacterReviewModelTests {         ]         let workID = UUID()         let mock = MockLibraryProvider()-        mock.commitCharacterDecisionResult = .success(.refused(.staleSource(.genericNotes)))+        mock.commitDecisionResult = .success(.refused(.staleSource(.genericNotes)))         mock.workDetailResult = .success(Self.workPresentation(workID: workID, characters: []))         let model = CharacterReviewModel(             workID: workID, proposals: held, characters: [], library: mock,-            onDecision: { _ in }, onReRoute: { _, _ in }, refresh: { held })+            extractionContext: { nil },+            onDecision: { _, _ in }, onReRoute: { _, _ in }, onReclassify: { _, _, _ in },+            refresh: { held }) -        model.setStruck(true, alias: "Nightjar", in: "ada")-        await model.accept("ada")+        model.setStruck(true, alias: "Nightjar", in: Self.rowID("ada"))+        await model.accept(Self.rowID("ada")) -        #expect(model.rows.first { $0.id == "ada" }?.aliases.first?.isStruck == true)         #expect(-            model.rows.first { $0.id == "brede" }?.aliases.first?.isStruck == false,+            model.rows.first { $0.id == Self.rowID("ada") }?.aliases.first?.isStruck == true)+        #expect(+            model.rows.first { $0.id == Self.rowID("brede") }?.aliases.first?.isStruck == false,             "Brede's alias is Brede's decision")     } @@ -580,10 +1113,10 @@ struct CharacterReviewModelTests {     func duplicateSubmissionSuppressed() async {         let (model, mock) = makeSUT() -        async let first: Void = model.accept("ada")-        await model.accept("ada")+        async let first: Void = model.accept(Self.rowID("ada"))+        await model.accept(Self.rowID("ada"))         await first -        #expect(mock.committedCharacterDecisions.count == 1)+        #expect(mock.committedDecisions.count == 1)     } }