id(artifact): a blank line in artifacts.jsonl bricks Directory::open — and its torn-tail truncation is silent

Summary

ArtifactLog::open (pkgs/id/src/artifact.rs:573-593, main 0f5b4cbb) parses
every line of the artifact journal strictly. A single blank line — in the
middle, as a trailing extra newline (...\n\n), or as the file's only
content — fails the whole open with artifact line N is corrupt, even though
every artifact in the file is intact. ArtifactLog is loaded by
Directory::open (pkgs/id/src/directory.rs:473), so the failure takes the
whole directory down with it.

The sibling journal loaded in the very same Directory::open treats blank
lines differently: Directory::replay explicitly skips them
(directory.rs:535-537: if line.trim().is_empty() { continue; }).

Second divergence in the same function: when open drops a crash-torn final
line it truncates the file with no log line at all (artifact.rs:578-584).
Both sibling loaders warn with the byte offset when they do exactly this —
Directory::replay at directory.rs:525-528 ("dropping torn final entry at
byte {kept_len}") and FileJournal::open at world_store.rs:116-119. A torn
artifact tail therefore loses a signed artifact (e.g. a friend-removal record
replayed at directory.rs:475-490) with no trace anywhere.

Evidence (verified this run)

Laptop probe ~/git/fleet/probe-2026-10-29-artifactlog/ — the open loop
copied verbatim from artifact.rs (main 0f5b4cbb), artifacts as minimal
JSON objects, run 2026-10-29:

Blank lines reach this file in ordinary ways: a hand edit, an editor that
adds a final newline, a restore/sync that appends one. Nothing in the append
path (artifact.rs:601-608, one line + \n per write) ever needs a blank
line to be fatal.

Why it matters

• Availability: one stray newline makes Directory::open fail, which is on
  the world-open path (world_store.rs open_world loads the directory) —
  the directory is down until someone hand-repairs the file, despite zero
  corrupt artifacts.
• Observability: the silent truncation is the only one of the three JSONL
  loaders in this crate that drops data without a warning, so a lost
  artifact leaves nothing to investigate.

Acceptance criteria

• ArtifactLog::open skips blank/whitespace-only lines the way
  Directory::replay does; a file with blank lines in any position
  (including a \n\n ending and a blank-only file) opens with all its
  artifacts intact.
• The torn-tail truncation in ArtifactLog::open emits a warning naming
  the file and the byte offset, matching the Directory::replay /
  FileJournal::open wording.
• A genuinely corrupt non-blank line still fails the open with the
  existing artifact line N is corrupt context.
• Regression tests cover: blank middle, blank final, blank-only, torn
  tail (opens, truncates, warns), and corrupt-line refusal.

Dedup

Searched open + closed issues for "ArtifactLog", "artifact blank line" and
"torn": #1521 (closed) fixed the same class for Directory::replay and notes
ArtifactLog is "loaded in the same open", but covered only the torn tail of
the directory journal, not the artifact log's blank-line refusal or its
silent truncation. #1499/#1522/#1523/#1544/#1620 are the petname, group,
world-fork, records and outbox loaders respectively — none touches
artifact.rs.