chore: import upstream snapshot with attribution

docs/dev/crate-splitting-plan.md

@@ -0,0 +1,58 @@
+# Compile-time crate splitting plan
+
+## Goal
+
+Minimize the amount of code that must be rechecked or rebuilt when iterating on
+Jcode. The root `jcode` crate is still the integration shell, but stable leaf
+code should live in small crates with one-way dependencies.
+
+## Principles
+
+1. Extract stable leaves first: filesystem/storage, protocol/types, parsers,
+   provider request/stream codecs, and TUI render primitives.
+2. Avoid cyclic domain crates. Root `jcode` may depend on leaf crates, but leaf
+   crates must not call back into root logging/config/runtime directly. Use data
+   types, callbacks, or explicit events at boundaries.
+3. Split by recompilation volatility, not by directory names. Code edited often
+   should not force heavy provider/TUI/server modules to rebuild unless needed.
+4. Keep heavy optional dependencies behind crates/features. Embeddings, PDF,
+   desktop/mobile, browser, and image/render pipelines should remain isolated.
+5. Preserve compatibility facades during migration. `crate::storage::*` can
+   re-export `jcode-storage::*` while callers move gradually.
+
+## Current first step
+
+`jcode-storage` is now a leaf crate for app paths, permission hardening, atomic
+JSON writes, and append-only JSONL helpers. The root `src/storage.rs` module is a
+thin compatibility facade that preserves existing logging behavior for backup
+recovery.
+
+Measured after extraction on this machine:
+
+- `cargo check -p jcode-storage`: ~0.9s after initial dependencies were built.
+- `cargo check -p jcode --lib`: ~14s in the current warm-cache state.
+
+## Recommended next extractions
+
+1. `jcode-provider-anthropic`: move Anthropic request/stream translation out of
+   root `src/provider/anthropic.rs` and depend only on `jcode-provider-core`,
+   `jcode-message-types`, and serde/reqwest primitives.
+2. `jcode-provider-openai`: same for OpenAI request/stream handling. This
+   reduces rebuilds when editing server/TUI code and makes provider tests cheap.
+3. `jcode-session-core`: move session storage paths, journal metadata, and
+   memory-profile pure transforms once dependencies on root prompt/logging are
+   cut behind callbacks.
+4. `jcode-tui-app-state`: split key/input/navigation state transitions from
+   rendering. Keep ratatui rendering in `jcode-tui-render`/root while state tests
+   compile without the whole root crate.
+5. `jcode-server-protocol-runtime`: split websocket/client event fanout glue from
+   agent execution so server tests do not rebuild TUI/provider internals.
+
+## Anti-patterns to avoid
+
+- Extracting crates that depend on root `jcode`. That preserves the compile-time
+  bottleneck and creates dependency cycles.
+- Tiny crates for every file. Too many crates increase metadata overhead and make
+  refactors painful.
+- Moving only type aliases while leaving implementations in root. The expensive
+  compile units remain expensive.