merge: P6, the evidence pipeline (branch P6, checkpoint ce366408)

The last of the paused branches, from its "not for merge" checkpoint:
extraction in ledger-import (text, pages, page images; capped, caught),
journaled as attachment.text_extracted; dedup by hash with
books.find_attachment and books.consolidate_duplicates; annotations and
books.set_entry_settles; the company record categories; the two fuzz
targets; feature attachment_text. Nineteen files conflicted with the
four P4b merges, resolved as plan 8.0.2 says: P6 retakes schema 18 (it
had taken 16, which S4.3 holds; S5 holds 17); the tool table is 129 and
the destructive count 31; both sides' appends kept with their seams
restored; one B-27 paragraph naming every feature; in the old-books
fixture P6's hand-written reimbursement is entry 7 (its ids collided
with S4.3's invoice); the replay fuzzer's list gains S7's
invoice.written_off; S4.3's issued-PDF test expects the extraction
record P6 journals right after a filing.

One integration defect between S7 and P6, found by the arap property
test and fixed here: under P6's dedup, a write-off whose evidence bytes
were filed already (the same collection letter for a second write-off of
the same invoice) was refused only after its entry had been journaled,
at the final link to the invoice ("already linked"). The write-off now
resolves the dedup before anything is journaled and keeps a link the
record already has to the invoice instead of refusing it; an explicit
existing_attachment_id already on an entry is still refused (S7's
one-receipt-once rule). P6's gate never ran before the pause; it runs on
main after this merge, and its ledger-store -> ledger-import dependency
is the open review point (plan 8.0.1).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HS8WZziDnyxunC23MUxrLp

crates/ledger-mcp/src/local.rs

@@ -497,6 +497,34 @@ impl Books {
                 expect_head,
             } => self.restore(id, source, replace, confirmed, expect_head),
             Request::UpgradeFormat { id, passphrase } => self.upgrade_format(id, &passphrase),
+            Request::Extract { id, attachment_id } => {
+                let id = match BookId::parse(&id) {
+                    Ok(id) => id,
+                    Err(e) => return refused(e),
+                };
+                let store = match self.held().get(id.as_str()) {
+                    Some(Book::Open { store, .. }) => store.clone(),
+                    Some(Book::Failed(why)) => {
+                        return Response::Refused(format!("those books didn't open: {why}"));
+                    }
+                    None => {
+                        return Response::Refused(format!(
+                            "there are no books called {:?}",
+                            id.as_str()
+                        ));
+                    }
+                };
+                match store.with_store_mut(|s| s.extract_attachment(attachment_id)) {
+                    Ok(Ok(x)) => Response::Extracted {
+                        attachment_id: x.attachment_id,
+                        status: x.status.key().to_string(),
+                        pages: x.pages,
+                        text_sha256: x.text_sha256,
+                    },
+                    Ok(Err(e)) => Response::Refused(self.hide(e.to_string())),
+                    Err(why) => Response::Refused(self.hide(why)),
+                }
+            }
             Request::BackUpNow { id, new_disk } => {
                 let id = match BookId::parse(&id) {
                     Ok(id) => id,