From 448cf31b39cff8db86af992645719f0453bb4a2c Mon Sep 17 00:00:00 2001
From: Konstantin Fickel <mail@konstantinfickel.de>
Date: Mon, 13 Apr 2026 21:37:38 +0200
Subject: [PATCH] feat: add streamd lsp subcommand with LSP server

Implements a full Language Server Protocol server accessible via
`streamd lsp`. The server communicates over stdin/stdout and auto-
detects the workspace root from the LSP initialize request.

Features implemented:
- Passive mode when no .streamd.toml exists in workspace root
- Workspace-root-based config loading (bypasses R22/R23 global config)
- .streamd.toml file watcher (config reloads without restart)
- textDocument/completion with @ trigger, conditional suggestions
  (if_with relationships), and temporal date/time snippets (R16)
- textDocument/publishDiagnostics: R15 file-name format + R18
  timesheet violations (overlapping timecards, unclosed days)
- textDocument/documentSymbol: shard tree exposed as nested symbols
- textDocument/codeAction: "Mark task as done" quickfix for @Task
- workspace/symbol: cross-file shard search
- textDocument/references: find all @Marker occurrences
- textDocument/rename: rename @Marker across all files

Dependencies added: tower-lsp 0.20, tokio, dashmap, serde_json
---
 Cargo.lock              |  652 ++++++++++++++++++++++-
 Cargo.toml              |    4 +
 src/cli/args.rs         |    3 +
 src/cli/commands/lsp.rs | 1112 +++++++++++++++++++++++++++++++++++++++
 src/cli/commands/mod.rs |    1 +
 src/main.rs             |    1 +
 6 files changed, 1769 insertions(+), 4 deletions(-)
 create mode 100644 src/cli/commands/lsp.rs

diff --git a/Cargo.lock b/Cargo.lock
index d70fe33..e393862 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -91,6 +91,28 @@ version = "1.0.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 
+[[package]]
+name = "async-trait"
+version = "0.1.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "auto_impl"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffdcb70bdbc4d478427380519163274ac86e52916e10f0a8889adf0f96d3fee7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "autocfg"
 version = "1.5.0"
@@ -121,6 +143,12 @@ dependencies = [
  "backtrace",
 ]
 
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
 [[package]]
 name = "bitflags"
 version = "2.11.0"
@@ -133,6 +161,12 @@ version = "3.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
 
+[[package]]
+name = "bytes"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+
 [[package]]
 name = "cc"
 version = "1.2.60"
@@ -234,6 +268,39 @@ version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "dashmap"
+version = "5.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
+dependencies = [
+ "cfg-if",
+ "hashbrown 0.14.5",
+ "lock_api",
+ "once_cell",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "dashmap"
+version = "6.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5041cc499144891f3790297212f32a74fb938e5136a14943f338ef9e0ae276cf"
+dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+ "hashbrown 0.14.5",
+ "lock_api",
+ "once_cell",
+ "parking_lot_core",
+]
+
 [[package]]
 name = "diff"
 version = "0.1.13"
@@ -261,6 +328,17 @@ dependencies = [
  "windows-sys",
 ]
 
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "either"
 version = "1.15.0"
@@ -301,6 +379,91 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
 
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "futures"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
+
+[[package]]
+name = "futures-io"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
+
+[[package]]
+name = "futures-macro"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
+
+[[package]]
+name = "futures-task"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
+
+[[package]]
+name = "futures-util"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "slab",
+]
+
 [[package]]
 name = "getopts"
 version = "0.2.24"
@@ -340,6 +503,12 @@ version = "0.32.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
 
+[[package]]
+name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+
 [[package]]
 name = "hashbrown"
 version = "0.15.5"
@@ -361,6 +530,12 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
 [[package]]
 name = "iana-time-zone"
 version = "0.1.65"
@@ -385,12 +560,115 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "icu_collections"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2984d1cd16c883d7935b9e07e44071dca8d917fd52ecc02c04d5fa0b5a3f191c"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "utf8_iter",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92219b62b3e2b4d88ac5119f8904c10f8f61bf7e95b640d25ba3075e6cac2c29"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c56e5ee99d6e3d33bd91c5d85458b6005a22140021cc324cea84dd0e72cff3b4"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da3be0ae77ea334f4da67c12f149704f19f81d1adf7c51cf482943e84a2bad38"
+
+[[package]]
+name = "icu_properties"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bee3b67d0ea5c2cca5003417989af8996f8604e34fb9ddf96208a033901e70de"
+dependencies = [
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e2bbb201e0c04f7b4b3e14382af113e17ba4f63e2c9d2ee626b720cbce54a14"
+
+[[package]]
+name = "icu_provider"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "139c4cf31c8b5f33d7e199446eff9c1e02decfc2f0eec2c8d71f65befa45b421"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
 [[package]]
 name = "id-arena"
 version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
 
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
 [[package]]
 name = "indexmap"
 version = "2.14.0"
@@ -467,12 +745,40 @@ version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
 
+[[package]]
+name = "litemap"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92daf443525c4cce67b150400bc2316076100ce0b3686209eb8cf3c31612e6f0"
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
 [[package]]
 name = "log"
 version = "0.4.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
+[[package]]
+name = "lsp-types"
+version = "0.94.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c66bfd44a06ae10647fe3f8214762e9369fd4248df1350924b4ef9e770a85ea1"
+dependencies = [
+ "bitflags 1.3.2",
+ "serde",
+ "serde_json",
+ "serde_repr",
+ "url",
+]
+
 [[package]]
 name = "memchr"
 version = "2.8.0"
@@ -560,6 +866,25 @@ version = "4.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d211803b9b6b570f68772237e415a029d5a50c65d382910b879fb19d3271f94d"
 
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-link",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
 [[package]]
 name = "phf"
 version = "0.12.1"
@@ -578,6 +903,41 @@ dependencies = [
  "siphasher",
 ]
 
+[[package]]
+name = "pin-project"
+version = "1.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1749c7ed4bcaf4c3d0a3efc28538844fb29bcdd7d2b67b2be7e20ba861ff517"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b20ed30f105399776b9c883e68e536ef602a16ae6f596d2c473591d6ad64c6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+
+[[package]]
+name = "potential_utf"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0103b1cef7ec0cf76490e969665504990193874ea05c85ff9bab8b911d0a0564"
+dependencies = [
+ "zerovec",
+]
+
 [[package]]
 name = "pretty_assertions"
 version = "1.4.1"
@@ -613,7 +973,7 @@ version = "0.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7c3a14896dfa883796f1cb410461aef38810ea05f2b2c33c5aded3649095fdad"
 dependencies = [
- "bitflags",
+ "bitflags 2.11.0",
  "getopts",
  "memchr",
  "pulldown-cmark-escape",
@@ -641,6 +1001,15 @@ version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
 
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags 2.11.0",
+]
+
 [[package]]
 name = "redox_users"
 version = "0.5.2"
@@ -693,7 +1062,7 @@ version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
 dependencies = [
- "bitflags",
+ "bitflags 2.11.0",
  "errno",
  "libc",
  "linux-raw-sys",
@@ -715,6 +1084,12 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
 [[package]]
 name = "semver"
 version = "1.0.28"
@@ -764,6 +1139,17 @@ dependencies = [
  "zmij",
 ]
 
+[[package]]
+name = "serde_repr"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "serde_spanned"
 version = "1.1.1"
@@ -785,6 +1171,24 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b2aa850e253778c88a04c3d7323b043aeda9d3e30d5971937c1855769763678e"
 
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
 [[package]]
 name = "streamd"
 version = "0.2.4"
@@ -793,6 +1197,7 @@ dependencies = [
  "chrono-tz",
  "clap",
  "clap_complete",
+ "dashmap 6.1.0",
  "directories",
  "indexmap",
  "itertools",
@@ -802,9 +1207,12 @@ dependencies = [
  "pulldown-cmark",
  "regex",
  "serde",
+ "serde_json",
  "tempfile",
  "thiserror",
+ "tokio",
  "toml",
+ "tower-lsp",
  "walkdir",
 ]
 
@@ -846,6 +1254,17 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "tempfile"
 version = "3.27.0"
@@ -899,6 +1318,38 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "tinystr"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8323304221c2a851516f22236c5722a72eaa19749016521d6dff0824447d96d"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "tokio"
+version = "1.51.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f66bf9585cda4b724d3e78ab34b73fb2bbaba9011b9bfdf69dc836382ea13b8c"
+dependencies = [
+ "pin-project-lite",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio",
+]
+
 [[package]]
 name = "toml"
 version = "1.1.2+spec-1.1.0"
@@ -938,6 +1389,97 @@ version = "1.1.1+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "756daf9b1013ebe47a8776667b466417e2d4c5679d441c26230efd9ef78692db"
 
+[[package]]
+name = "tower"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c"
+dependencies = [
+ "futures-core",
+ "futures-util",
+ "pin-project",
+ "pin-project-lite",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "tower-layer"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
+
+[[package]]
+name = "tower-lsp"
+version = "0.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4ba052b54a6627628d9b3c34c176e7eda8359b7da9acd497b9f20998d118508"
+dependencies = [
+ "async-trait",
+ "auto_impl",
+ "bytes",
+ "dashmap 5.5.3",
+ "futures",
+ "httparse",
+ "lsp-types",
+ "memchr",
+ "serde",
+ "serde_json",
+ "tokio",
+ "tokio-util",
+ "tower",
+ "tower-lsp-macros",
+ "tracing",
+]
+
+[[package]]
+name = "tower-lsp-macros"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84fd902d4e0b9a4b27f2f440108dc034e1758628a9b702f8ec61ad66355422fa"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tower-service"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
+
+[[package]]
+name = "tracing"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+dependencies = [
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+dependencies = [
+ "once_cell",
+]
+
 [[package]]
 name = "unicase"
 version = "2.9.0"
@@ -974,6 +1516,25 @@ version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
+[[package]]
+name = "url"
+version = "2.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+ "serde_derive",
+]
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
 [[package]]
 name = "utf8parse"
 version = "0.2.2"
@@ -1087,7 +1648,7 @@ version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
 dependencies = [
- "bitflags",
+ "bitflags 2.11.0",
  "hashbrown 0.15.5",
  "indexmap",
  "semver",
@@ -1234,7 +1795,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
 dependencies = [
  "anyhow",
- "bitflags",
+ "bitflags 2.11.0",
  "indexmap",
  "log",
  "serde",
@@ -1264,12 +1825,95 @@ dependencies = [
  "wasmparser",
 ]
 
+[[package]]
+name = "writeable"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4"
+
 [[package]]
 name = "yansi"
 version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
 
+[[package]]
+name = "yoke"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "abe8c5fda708d9ca3df187cae8bfb9ceda00dd96231bed36e445a1a48e66f9ca"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69faa1f2a1ea75661980b013019ed6687ed0e83d069bc1114e2cc74c6c04c4df"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zerotrie"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f9152d31db0792fa83f70fb2f83148effb5c1f5b8c7686c3459e361d9bc20bf"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90f911cbc359ab6af17377d242225f4d75119aec87ea711a880987b18cd7b239"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "625dc425cab0dca6dc3c3319506e6593dcb08a9f387ea3b284dbd52a92c40555"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "zmij"
 version = "1.0.21"
diff --git a/Cargo.toml b/Cargo.toml
index dc2b964..77658cf 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -11,6 +11,7 @@ repository = "https://github.com/konstantinfickel/streamd"
 clap = { version = "4", features = ["derive", "env"] }
 clap_complete = "4"
 serde = { version = "1", features = ["derive"] }
+serde_json = "1"
 toml = "1.0"
 thiserror = "2"
 miette = { version = "7", features = ["fancy"] }
@@ -23,6 +24,9 @@ walkdir = "2"
 indexmap = { version = "2", features = ["serde"] }
 itertools = "0.14"
 directories = "6"
+tower-lsp = "0.20"
+tokio = { version = "1", features = ["rt-multi-thread", "io-std"] }
+dashmap = "6"
 
 [dev-dependencies]
 pretty_assertions = "=1.4.1"
diff --git a/src/cli/args.rs b/src/cli/args.rs
index f45387f..5666337 100644
--- a/src/cli/args.rs
+++ b/src/cli/args.rs
@@ -72,4 +72,7 @@ pub enum Commands {
         #[arg(value_enum)]
         shell: Shell,
     },
+
+    /// Start LSP server (communicates over stdin/stdout)
+    Lsp,
 }
diff --git a/src/cli/commands/lsp.rs b/src/cli/commands/lsp.rs
new file mode 100644
index 0000000..ba3886a
--- /dev/null
+++ b/src/cli/commands/lsp.rs
@@ -0,0 +1,1112 @@
+use std::fs;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use chrono::{Timelike, Utc};
+use chrono_tz::Tz;
+use dashmap::DashMap;
+use once_cell::sync::Lazy;
+use regex::Regex;
+use tokio::sync::RwLock;
+use tower_lsp::jsonrpc::Result;
+use tower_lsp::lsp_types::*;
+use tower_lsp::{Client, LanguageServer, LspService, Server};
+use walkdir::WalkDir;
+
+use crate::error::StreamdError;
+use crate::extract::parse_markdown_file;
+use crate::localize::{localize_stream_file, merge_repository_configuration, TaskConfiguration};
+use crate::models::{LocalizedShard, RepositoryConfiguration};
+use crate::timesheet::{
+    extract_timesheets, find_overlapping_timecards, load_repository_config,
+    BasicTimesheetConfiguration,
+};
+
+// ---------------------------------------------------------------------------
+// Constants and helpers
+// ---------------------------------------------------------------------------
+
+/// R15 file name validation: YYYYMMDD[-HHMMSS][_type][...].md
+/// The extraction regex requires at least one non-dot char after date/time.
+static FILE_NAME_REGEX: Lazy<Regex> =
+    Lazy::new(|| Regex::new(r"^(?P<date>\d{8})(?:-(?P<time>\d{4,6}))?.+\.md$").unwrap());
+
+/// Collect all `@Word` marker names present on a line.
+pub fn extract_markers_from_line(line: &str) -> Vec<String> {
+    let mut markers = Vec::new();
+    let mut remaining = line;
+    while let Some(at_pos) = remaining.find('@') {
+        remaining = &remaining[at_pos + 1..];
+        let end = remaining
+            .find(|c: char| !c.is_alphanumeric() && c != '_')
+            .unwrap_or(remaining.len());
+        let marker = &remaining[..end];
+        if !marker.is_empty() {
+            markers.push(marker.to_string());
+        }
+        remaining = &remaining[end..];
+    }
+    markers
+}
+
+/// Extract the marker name under the cursor (the word after the nearest `@`).
+/// `cursor_col` is the 0-indexed character offset; the character *at* that
+/// offset is treated as part of the cursor position (inclusive).
+pub fn extract_marker_at_position(line: &str, cursor_col: u32) -> Option<String> {
+    // +1 so the character at the cursor itself is included in the search.
+    let col = ((cursor_col as usize).saturating_add(1)).min(line.len());
+    let line_prefix = &line[..col];
+    let at_pos = line_prefix.rfind('@')?;
+
+    let after_at = &line[at_pos + 1..];
+    let end = after_at
+        .find(|c: char| !c.is_alphanumeric() && c != '_')
+        .unwrap_or(after_at.len());
+
+    // Cursor must be within or at the end of the marker word.
+    if col > at_pos + 1 + end {
+        return None;
+    }
+
+    let marker = &after_at[..end];
+    if marker.is_empty() {
+        None
+    } else {
+        Some(marker.to_string())
+    }
+}
+
+/// Produce a file-name diagnostic if the basename does not match R15.
+pub fn compute_file_name_diagnostic(file_name: &str) -> Option<Diagnostic> {
+    if !file_name.ends_with(".md") {
+        return None;
+    }
+    if FILE_NAME_REGEX.is_match(file_name) {
+        return None;
+    }
+    Some(Diagnostic {
+        range: Range {
+            start: Position::new(0, 0),
+            end: Position::new(0, 0),
+        },
+        severity: Some(DiagnosticSeverity::WARNING),
+        source: Some("streamd".to_string()),
+        message: "File name does not match streamd format: \
+                  YYYYMMDD-HHMMSS[_type] [markers].md"
+            .to_string(),
+        ..Default::default()
+    })
+}
+
+/// Build completion items for a given line and cursor position.
+pub fn completions_for_line(
+    line: &str,
+    cursor_col: u32,
+    config: &RepositoryConfiguration,
+) -> Vec<CompletionItem> {
+    let col = (cursor_col as usize).min(line.len());
+    let line_prefix = &line[..col];
+
+    // Only trigger when there is a `@` before the cursor.
+    let at_pos = match line_prefix.rfind('@') {
+        Some(p) => p,
+        None => return vec![],
+    };
+
+    let after_at = &line_prefix[at_pos + 1..];
+
+    // Temporal snippet: `@` followed by a digit → offer date/time format snippets.
+    if after_at.starts_with(|c: char| c.is_ascii_digit()) {
+        return vec![
+            CompletionItem {
+                label: "YYYYMMDD".to_string(),
+                kind: Some(CompletionItemKind::SNIPPET),
+                detail: Some("Date marker (R16)".to_string()),
+                insert_text: Some("${1:YYYYMMDD}".to_string()),
+                insert_text_format: Some(InsertTextFormat::SNIPPET),
+                ..Default::default()
+            },
+            CompletionItem {
+                label: "HHMMSS".to_string(),
+                kind: Some(CompletionItemKind::SNIPPET),
+                detail: Some("Time marker (R16)".to_string()),
+                insert_text: Some("${1:HHMMSS}".to_string()),
+                insert_text_format: Some(InsertTextFormat::SNIPPET),
+                ..Default::default()
+            },
+        ];
+    }
+
+    // Markers already on this line (for conditional suggestion logic).
+    let existing: Vec<String> = extract_markers_from_line(line);
+
+    // Collect markers whose `if_with` conditions are satisfied by existing markers:
+    // if marker M has a placement with `if_with: {A, B}`, and A is on the line,
+    // then B is a candidate to suggest.
+    let mut conditional: std::collections::HashSet<String> = std::collections::HashSet::new();
+    for existing_name in &existing {
+        if let Some(marker_def) = config.markers.get(existing_name) {
+            for placement in &marker_def.placements {
+                for cond in &placement.if_with {
+                    if !existing.contains(cond) {
+                        conditional.insert(cond.clone());
+                    }
+                }
+            }
+        }
+    }
+
+    // Filter by typed prefix.
+    let prefix = after_at.to_lowercase();
+    let mut items: Vec<CompletionItem> = config
+        .markers
+        .iter()
+        .filter(|(name, _)| name.to_lowercase().starts_with(&prefix))
+        .map(|(name, marker)| {
+            let is_conditional = conditional.contains(name.as_str());
+            CompletionItem {
+                label: format!("@{}", name),
+                kind: Some(CompletionItemKind::KEYWORD),
+                detail: Some(marker.display_name.clone()),
+                // Conditional completions sort before unconditional ones.
+                sort_text: Some(if is_conditional {
+                    format!("0_{}", name)
+                } else {
+                    format!("1_{}", name)
+                }),
+                ..Default::default()
+            }
+        })
+        .collect();
+
+    items.sort_by(|a, b| {
+        a.sort_text
+            .as_deref()
+            .unwrap_or("")
+            .cmp(b.sort_text.as_deref().unwrap_or(""))
+    });
+
+    items
+}
+
+/// Convert a `LocalizedShard` tree node to a `DocumentSymbol`.
+fn shard_to_document_symbol(shard: &LocalizedShard) -> DocumentSymbol {
+    let name = if !shard.markers.is_empty() {
+        shard.markers.join(" @")
+    } else if !shard.tags.is_empty() {
+        shard.tags.join(" @")
+    } else {
+        "(shard)".to_string()
+    };
+
+    let start_line = shard.start_line.saturating_sub(1) as u32;
+    let end_line = shard.end_line.saturating_sub(1) as u32;
+
+    let range = Range {
+        start: Position::new(start_line, 0),
+        end: Position::new(end_line, u32::MAX),
+    };
+    let selection_range = Range {
+        start: Position::new(start_line, 0),
+        end: Position::new(start_line, u32::MAX),
+    };
+
+    let children: Vec<DocumentSymbol> = shard
+        .children
+        .iter()
+        .map(shard_to_document_symbol)
+        .collect();
+
+    #[allow(deprecated)]
+    DocumentSymbol {
+        name,
+        detail: None,
+        kind: SymbolKind::STRING,
+        tags: None,
+        deprecated: None,
+        range,
+        selection_range,
+        children: if children.is_empty() {
+            None
+        } else {
+            Some(children)
+        },
+    }
+}
+
+/// Collect workspace symbols from a shard tree, filtering by query.
+fn collect_workspace_symbols(
+    shard: &LocalizedShard,
+    uri: &Url,
+    query: &str,
+    out: &mut Vec<SymbolInformation>,
+) {
+    let name = if !shard.markers.is_empty() {
+        shard.markers.join(" @")
+    } else if !shard.tags.is_empty() {
+        shard.tags.join(" @")
+    } else {
+        return;
+    };
+
+    if query.is_empty() || name.to_lowercase().contains(query) {
+        let start_line = shard.start_line.saturating_sub(1) as u32;
+        let end_line = shard.end_line.saturating_sub(1) as u32;
+        #[allow(deprecated)]
+        out.push(SymbolInformation {
+            name: name.clone(),
+            kind: SymbolKind::STRING,
+            tags: None,
+            deprecated: None,
+            location: Location {
+                uri: uri.clone(),
+                range: Range {
+                    start: Position::new(start_line, 0),
+                    end: Position::new(end_line, 0),
+                },
+            },
+            container_name: None,
+        });
+    }
+
+    for child in &shard.children {
+        collect_workspace_symbols(child, uri, query, out);
+    }
+}
+
+// ---------------------------------------------------------------------------
+// LSP state
+// ---------------------------------------------------------------------------
+
+struct LspState {
+    config: RepositoryConfiguration,
+    tz: Tz,
+    base_folder: PathBuf,
+    /// URI → localized shard root (None when file could not be localized)
+    file_cache: DashMap<Url, Option<LocalizedShard>>,
+    /// URI → lines of text (for line-based operations)
+    file_lines: DashMap<Url, Vec<String>>,
+}
+
+impl LspState {
+    /// Parse `text` for `uri`, update caches.
+    fn parse_and_cache(&self, uri: &Url, text: &str) {
+        let lines: Vec<String> = text.lines().map(String::from).collect();
+        self.file_lines.insert(uri.clone(), lines);
+
+        let path_str = uri.path();
+        let stream_file = parse_markdown_file(path_str, text);
+        let localized = localize_stream_file(&stream_file, &self.config, self.tz).ok();
+        self.file_cache.insert(uri.clone(), localized);
+    }
+
+    /// Parse a file from disk on demand (for cross-file features).
+    fn parse_file_from_disk(&self, path: &std::path::Path) -> Option<LocalizedShard> {
+        let text = fs::read_to_string(path).ok()?;
+        let path_str = path.to_string_lossy();
+        let stream_file = parse_markdown_file(&path_str, &text);
+        localize_stream_file(&stream_file, &self.config, self.tz).ok()
+    }
+
+    /// Ensure a file's lines are in `file_lines` (read from disk if not cached).
+    fn ensure_lines(&self, uri: &Url, path: &std::path::Path) -> Option<Vec<String>> {
+        if let Some(cached) = self.file_lines.get(uri) {
+            return Some(cached.clone());
+        }
+        let text = fs::read_to_string(path).ok()?;
+        let lines: Vec<String> = text.lines().map(String::from).collect();
+        self.file_lines.insert(uri.clone(), lines.clone());
+        Some(lines)
+    }
+
+    /// Compute diagnostics for `uri`:
+    ///   - R15 file-name format
+    ///   - R18 timesheet violations
+    fn compute_diagnostics(&self, uri: &Url) -> Vec<Diagnostic> {
+        let mut diags = Vec::new();
+
+        // File-name format (R15)
+        if let Some(name) = uri.path_segments().and_then(|mut s| s.next_back()) {
+            if let Some(d) = compute_file_name_diagnostic(name) {
+                diags.push(d);
+            }
+        }
+
+        // Timesheet diagnostics (R18)
+        if let Some(entry) = self.file_cache.get(uri) {
+            if let Some(root) = entry.as_ref() {
+                let now = Utc::now();
+                match extract_timesheets(std::slice::from_ref(root), now, self.tz) {
+                    Ok(timesheets) => {
+                        for ts in &timesheets {
+                            for (first, second) in find_overlapping_timecards(&ts.timecards) {
+                                diags.push(Diagnostic {
+                                    range: Range {
+                                        start: Position::new(0, 0),
+                                        end: Position::new(0, 0),
+                                    },
+                                    severity: Some(DiagnosticSeverity::WARNING),
+                                    source: Some("streamd".to_string()),
+                                    message: format!(
+                                        "Overlapping timecards on {}: \
+                                         {:02}:{:02}-{:02}:{:02} overlaps \
+                                         {:02}:{:02}-{:02}:{:02}",
+                                        ts.date,
+                                        first.0.hour(),
+                                        first.0.minute(),
+                                        first.1.hour(),
+                                        first.1.minute(),
+                                        second.0.hour(),
+                                        second.0.minute(),
+                                        second.1.hour(),
+                                        second.1.minute(),
+                                    ),
+                                    ..Default::default()
+                                });
+                            }
+                        }
+                    }
+                    Err(e) => {
+                        // Unclosed day or conflicting day types → Error
+                        diags.push(Diagnostic {
+                            range: Range {
+                                start: Position::new(0, 0),
+                                end: Position::new(0, 0),
+                            },
+                            severity: Some(DiagnosticSeverity::ERROR),
+                            source: Some("streamd".to_string()),
+                            message: format!("Timesheet error: {}", e),
+                            ..Default::default()
+                        });
+                    }
+                }
+            }
+        }
+
+        diags
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Backend
+// ---------------------------------------------------------------------------
+
+struct Backend {
+    client: Client,
+    /// None → passive mode (no .streamd.toml found)
+    state: RwLock<Option<Arc<LspState>>>,
+}
+
+impl Backend {
+    fn new(client: Client) -> Self {
+        Backend {
+            client,
+            state: RwLock::new(None),
+        }
+    }
+
+    async fn build_state(root: PathBuf) -> Option<Arc<LspState>> {
+        let config_path = root.join(".streamd.toml");
+        if !config_path.exists() {
+            return None;
+        }
+        let repo_config = load_repository_config(&root).ok()?;
+        let tz: Tz = repo_config
+            .timezone
+            .as_deref()
+            .and_then(|s| s.parse().ok())
+            .unwrap_or(chrono_tz::UTC);
+
+        let config =
+            merge_repository_configuration(&*BasicTimesheetConfiguration, &*TaskConfiguration);
+
+        Some(Arc::new(LspState {
+            config,
+            tz,
+            base_folder: root,
+            file_cache: DashMap::new(),
+            file_lines: DashMap::new(),
+        }))
+    }
+}
+
+// ---------------------------------------------------------------------------
+// LanguageServer implementation
+// ---------------------------------------------------------------------------
+
+#[tower_lsp::async_trait]
+impl LanguageServer for Backend {
+    async fn initialize(&self, params: InitializeParams) -> Result<InitializeResult> {
+        let root: Option<PathBuf> = params
+            .root_uri
+            .as_ref()
+            .and_then(|u| u.to_file_path().ok())
+            .or_else(|| params.root_path.as_ref().map(PathBuf::from));
+
+        if let Some(root) = root {
+            match Backend::build_state(root).await {
+                Some(state) => {
+                    *self.state.write().await = Some(state);
+                    self.client
+                        .log_message(
+                            MessageType::INFO,
+                            "streamd LSP: active (found .streamd.toml)",
+                        )
+                        .await;
+                }
+                None => {
+                    self.client
+                        .log_message(
+                            MessageType::INFO,
+                            "streamd LSP: passive mode (no .streamd.toml in workspace root)",
+                        )
+                        .await;
+                }
+            }
+        }
+
+        Ok(InitializeResult {
+            capabilities: ServerCapabilities {
+                text_document_sync: Some(TextDocumentSyncCapability::Options(
+                    TextDocumentSyncOptions {
+                        open_close: Some(true),
+                        change: Some(TextDocumentSyncKind::FULL),
+                        save: Some(TextDocumentSyncSaveOptions::SaveOptions(SaveOptions {
+                            include_text: Some(true),
+                        })),
+                        ..Default::default()
+                    },
+                )),
+                completion_provider: Some(CompletionOptions {
+                    trigger_characters: Some(vec!["@".to_string()]),
+                    ..Default::default()
+                }),
+                document_symbol_provider: Some(OneOf::Left(true)),
+                code_action_provider: Some(CodeActionProviderCapability::Simple(true)),
+                workspace_symbol_provider: Some(OneOf::Left(true)),
+                references_provider: Some(OneOf::Left(true)),
+                rename_provider: Some(OneOf::Left(true)),
+                ..Default::default()
+            },
+            server_info: Some(ServerInfo {
+                name: "streamd-lsp".to_string(),
+                version: Some(env!("CARGO_PKG_VERSION").to_string()),
+            }),
+        })
+    }
+
+    async fn initialized(&self, _: InitializedParams) {
+        // Register a watcher for .streamd.toml so we can reload on change.
+        let opts = DidChangeWatchedFilesRegistrationOptions {
+            watchers: vec![FileSystemWatcher {
+                glob_pattern: GlobPattern::String("**/.streamd.toml".to_string()),
+                kind: Some(WatchKind::all()),
+            }],
+        };
+        if let Ok(opts_value) = serde_json::to_value(opts) {
+            let registration = Registration {
+                id: "streamd-config-watcher".to_string(),
+                method: "workspace/didChangeWatchedFiles".to_string(),
+                register_options: Some(opts_value),
+            };
+            let _ = self.client.register_capability(vec![registration]).await;
+        }
+    }
+
+    async fn shutdown(&self) -> Result<()> {
+        Ok(())
+    }
+
+    // -----------------------------------------------------------------------
+    // Config watching
+    // -----------------------------------------------------------------------
+
+    async fn did_change_watched_files(&self, params: DidChangeWatchedFilesParams) {
+        let has_config_change = params
+            .changes
+            .iter()
+            .any(|c| c.uri.path().ends_with(".streamd.toml"));
+        if !has_config_change {
+            return;
+        }
+
+        let base_folder: Option<PathBuf> = {
+            let guard = self.state.read().await;
+            guard.as_ref().map(|s| s.base_folder.clone())
+        };
+
+        if let Some(root) = base_folder {
+            match Backend::build_state(root).await {
+                Some(new_state) => {
+                    *self.state.write().await = Some(new_state);
+                    self.client
+                        .log_message(MessageType::INFO, "streamd LSP: reloaded .streamd.toml")
+                        .await;
+                }
+                None => {
+                    *self.state.write().await = None;
+                    self.client
+                        .log_message(
+                            MessageType::INFO,
+                            "streamd LSP: .streamd.toml removed, entering passive mode",
+                        )
+                        .await;
+                }
+            }
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // Document lifecycle
+    // -----------------------------------------------------------------------
+
+    async fn did_open(&self, params: DidOpenTextDocumentParams) {
+        let guard = self.state.read().await;
+        if let Some(state) = guard.as_ref() {
+            let uri = &params.text_document.uri;
+            state.parse_and_cache(uri, &params.text_document.text);
+            let diags = state.compute_diagnostics(uri);
+            self.client
+                .publish_diagnostics(uri.clone(), diags, None)
+                .await;
+        }
+    }
+
+    async fn did_change(&self, params: DidChangeTextDocumentParams) {
+        let guard = self.state.read().await;
+        if let Some(state) = guard.as_ref() {
+            let uri = &params.text_document.uri;
+            if let Some(change) = params.content_changes.into_iter().last() {
+                state.parse_and_cache(uri, &change.text);
+                let diags = state.compute_diagnostics(uri);
+                self.client
+                    .publish_diagnostics(uri.clone(), diags, None)
+                    .await;
+            }
+        }
+    }
+
+    async fn did_save(&self, params: DidSaveTextDocumentParams) {
+        let guard = self.state.read().await;
+        if let Some(state) = guard.as_ref() {
+            let uri = &params.text_document.uri;
+            if let Some(text) = params.text.as_deref() {
+                state.parse_and_cache(uri, text);
+            } else if let Ok(path) = uri.to_file_path() {
+                if let Ok(text) = fs::read_to_string(&path) {
+                    state.parse_and_cache(uri, &text);
+                }
+            }
+            let diags = state.compute_diagnostics(uri);
+            self.client
+                .publish_diagnostics(uri.clone(), diags, None)
+                .await;
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // Completion
+    // -----------------------------------------------------------------------
+
+    async fn completion(&self, params: CompletionParams) -> Result<Option<CompletionResponse>> {
+        let guard = self.state.read().await;
+        let state = match guard.as_ref() {
+            Some(s) => s,
+            None => return Ok(None),
+        };
+
+        let uri = &params.text_document_position.text_document.uri;
+        let position = params.text_document_position.position;
+
+        let lines = match state.file_lines.get(uri) {
+            Some(l) => l.clone(),
+            None => return Ok(None),
+        };
+        let line = lines
+            .get(position.line as usize)
+            .map(String::as_str)
+            .unwrap_or("");
+
+        Ok(Some(CompletionResponse::Array(completions_for_line(
+            line,
+            position.character,
+            &state.config,
+        ))))
+    }
+
+    // -----------------------------------------------------------------------
+    // Document symbols
+    // -----------------------------------------------------------------------
+
+    async fn document_symbol(
+        &self,
+        params: DocumentSymbolParams,
+    ) -> Result<Option<DocumentSymbolResponse>> {
+        let guard = self.state.read().await;
+        let state = match guard.as_ref() {
+            Some(s) => s,
+            None => return Ok(None),
+        };
+
+        let uri = &params.text_document.uri;
+        let entry = match state.file_cache.get(uri) {
+            Some(e) => e,
+            None => return Ok(None),
+        };
+        let root = match entry.as_ref() {
+            Some(r) => r,
+            None => return Ok(None),
+        };
+
+        Ok(Some(DocumentSymbolResponse::Nested(vec![
+            shard_to_document_symbol(root),
+        ])))
+    }
+
+    // -----------------------------------------------------------------------
+    // Code actions
+    // -----------------------------------------------------------------------
+
+    async fn code_action(&self, params: CodeActionParams) -> Result<Option<CodeActionResponse>> {
+        let guard = self.state.read().await;
+        if guard.is_none() {
+            return Ok(None);
+        }
+        // Drop the guard before the borrow ends — we only needed it to check active mode.
+        drop(guard);
+
+        let guard = self.state.read().await;
+        let state = match guard.as_ref() {
+            Some(s) => s,
+            None => return Ok(None),
+        };
+
+        let uri = &params.text_document.uri;
+        let lines = match state.file_lines.get(uri) {
+            Some(l) => l.clone(),
+            None => return Ok(None),
+        };
+
+        let mut actions: Vec<CodeActionOrCommand> = Vec::new();
+        let start_line = params.range.start.line as usize;
+        let end_line = params.range.end.line as usize;
+
+        for line_idx in start_line..=end_line.min(lines.len().saturating_sub(1)) {
+            let line = &lines[line_idx];
+            if line.contains("@Task") && !line.contains("@Done") {
+                let new_line = line.replacen("@Task", "@Task @Done", 1);
+                let mut changes: std::collections::HashMap<Url, Vec<TextEdit>> =
+                    std::collections::HashMap::new();
+                changes.insert(
+                    uri.clone(),
+                    vec![TextEdit {
+                        range: Range {
+                            start: Position::new(line_idx as u32, 0),
+                            end: Position::new(line_idx as u32, line.len() as u32),
+                        },
+                        new_text: new_line,
+                    }],
+                );
+                actions.push(CodeActionOrCommand::CodeAction(CodeAction {
+                    title: "Mark task as done".to_string(),
+                    kind: Some(CodeActionKind::QUICKFIX),
+                    edit: Some(WorkspaceEdit {
+                        changes: Some(changes),
+                        ..Default::default()
+                    }),
+                    ..Default::default()
+                }));
+            }
+        }
+
+        Ok(Some(actions))
+    }
+
+    // -----------------------------------------------------------------------
+    // Workspace symbols
+    // -----------------------------------------------------------------------
+
+    async fn symbol(
+        &self,
+        params: WorkspaceSymbolParams,
+    ) -> Result<Option<Vec<SymbolInformation>>> {
+        let guard = self.state.read().await;
+        let state = match guard.as_ref() {
+            Some(s) => s,
+            None => return Ok(None),
+        };
+
+        let query = params.query.to_lowercase();
+        let mut symbols = Vec::new();
+
+        for entry in WalkDir::new(&state.base_folder)
+            .max_depth(1)
+            .into_iter()
+            .filter_map(|e| e.ok())
+        {
+            let path = entry.path();
+            if !path.extension().map_or(false, |e| e == "md") {
+                continue;
+            }
+            let uri = match Url::from_file_path(path) {
+                Ok(u) => u,
+                Err(()) => continue,
+            };
+
+            let shard = if let Some(cached) = state.file_cache.get(&uri) {
+                cached.clone()
+            } else {
+                let parsed = state.parse_file_from_disk(path);
+                state.file_cache.insert(uri.clone(), parsed.clone());
+                parsed
+            };
+
+            if let Some(root) = shard {
+                collect_workspace_symbols(&root, &uri, &query, &mut symbols);
+            }
+        }
+
+        Ok(Some(symbols))
+    }
+
+    // -----------------------------------------------------------------------
+    // References
+    // -----------------------------------------------------------------------
+
+    async fn references(&self, params: ReferenceParams) -> Result<Option<Vec<Location>>> {
+        let guard = self.state.read().await;
+        let state = match guard.as_ref() {
+            Some(s) => s,
+            None => return Ok(None),
+        };
+
+        let uri = &params.text_document_position.text_document.uri;
+        let position = params.text_document_position.position;
+
+        let marker_name: Option<String> = {
+            let lines = match state.file_lines.get(uri) {
+                Some(l) => l.clone(),
+                None => return Ok(None),
+            };
+            let line = match lines.get(position.line as usize) {
+                Some(l) => l.clone(),
+                None => return Ok(None),
+            };
+            extract_marker_at_position(&line, position.character)
+        };
+
+        let marker_name = match marker_name {
+            Some(m) => m,
+            None => return Ok(Some(vec![])),
+        };
+
+        let pattern = format!("@{}", marker_name);
+        let mut locations = Vec::new();
+
+        for entry in WalkDir::new(&state.base_folder)
+            .max_depth(1)
+            .into_iter()
+            .filter_map(|e| e.ok())
+        {
+            let path = entry.path();
+            if !path.extension().map_or(false, |e| e == "md") {
+                continue;
+            }
+            let file_uri = match Url::from_file_path(path) {
+                Ok(u) => u,
+                Err(()) => continue,
+            };
+            let lines = match state.ensure_lines(&file_uri, path) {
+                Some(l) => l,
+                None => continue,
+            };
+
+            for (line_idx, line) in lines.iter().enumerate() {
+                let mut start = 0;
+                while let Some(pos) = line[start..].find(&pattern) {
+                    let abs = start + pos;
+                    let after = abs + pattern.len();
+                    // Ensure not part of a longer marker name.
+                    let is_word_boundary =
+                        after >= line.len() || !line.as_bytes()[after].is_ascii_alphanumeric();
+                    if is_word_boundary {
+                        locations.push(Location {
+                            uri: file_uri.clone(),
+                            range: Range {
+                                start: Position::new(line_idx as u32, abs as u32),
+                                end: Position::new(line_idx as u32, after as u32),
+                            },
+                        });
+                    }
+                    start = abs + pattern.len();
+                    if start >= line.len() {
+                        break;
+                    }
+                }
+            }
+        }
+
+        Ok(Some(locations))
+    }
+
+    // -----------------------------------------------------------------------
+    // Rename
+    // -----------------------------------------------------------------------
+
+    async fn rename(&self, params: RenameParams) -> Result<Option<WorkspaceEdit>> {
+        let guard = self.state.read().await;
+        let state = match guard.as_ref() {
+            Some(s) => s,
+            None => return Ok(None),
+        };
+
+        let uri = &params.text_document_position.text_document.uri;
+        let position = params.text_document_position.position;
+        // Strip leading `@` if the user typed it.
+        let new_name = params.new_name.trim_start_matches('@').to_string();
+
+        let marker_name: Option<String> = {
+            let lines = match state.file_lines.get(uri) {
+                Some(l) => l.clone(),
+                None => return Ok(None),
+            };
+            let line = match lines.get(position.line as usize) {
+                Some(l) => l.clone(),
+                None => return Ok(None),
+            };
+            extract_marker_at_position(&line, position.character)
+        };
+
+        let marker_name = match marker_name {
+            Some(m) => m,
+            None => return Ok(None),
+        };
+
+        let pattern = format!("@{}", marker_name);
+        let replacement = format!("@{}", new_name);
+        let mut changes: std::collections::HashMap<Url, Vec<TextEdit>> =
+            std::collections::HashMap::new();
+
+        for entry in WalkDir::new(&state.base_folder)
+            .max_depth(1)
+            .into_iter()
+            .filter_map(|e| e.ok())
+        {
+            let path = entry.path();
+            if !path.extension().map_or(false, |e| e == "md") {
+                continue;
+            }
+            let file_uri = match Url::from_file_path(path) {
+                Ok(u) => u,
+                Err(()) => continue,
+            };
+            let lines = match state.ensure_lines(&file_uri, path) {
+                Some(l) => l,
+                None => continue,
+            };
+
+            let mut file_edits: Vec<TextEdit> = Vec::new();
+            for (line_idx, line) in lines.iter().enumerate() {
+                let mut start = 0;
+                while let Some(pos) = line[start..].find(&pattern) {
+                    let abs = start + pos;
+                    let after = abs + pattern.len();
+                    let is_word_boundary =
+                        after >= line.len() || !line.as_bytes()[after].is_ascii_alphanumeric();
+                    if is_word_boundary {
+                        file_edits.push(TextEdit {
+                            range: Range {
+                                start: Position::new(line_idx as u32, abs as u32),
+                                end: Position::new(line_idx as u32, after as u32),
+                            },
+                            new_text: replacement.clone(),
+                        });
+                    }
+                    start = abs + pattern.len();
+                    if start >= line.len() {
+                        break;
+                    }
+                }
+            }
+            if !file_edits.is_empty() {
+                changes.insert(file_uri, file_edits);
+            }
+        }
+
+        Ok(Some(WorkspaceEdit {
+            changes: Some(changes),
+            ..Default::default()
+        }))
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+
+/// Run the LSP server over stdin/stdout.
+pub fn run() -> std::result::Result<(), StreamdError> {
+    let rt = tokio::runtime::Runtime::new().map_err(StreamdError::IoError)?;
+    rt.block_on(async {
+        let stdin = tokio::io::stdin();
+        let stdout = tokio::io::stdout();
+        let (service, socket) = LspService::new(Backend::new);
+        Server::new(stdin, stdout, socket).serve(service).await;
+    });
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::models::{Dimension, Marker, MarkerPlacement};
+
+    fn make_config() -> RepositoryConfiguration {
+        RepositoryConfiguration::new()
+            .with_dimension("task", Dimension::new("Task").with_propagate(false))
+            .with_marker(
+                "Task",
+                Marker::new("Task").with_placements(vec![
+                    MarkerPlacement::new("task").with_value("open"),
+                    MarkerPlacement::new("task")
+                        .with_if_with(vec!["Done"])
+                        .with_value("done"),
+                    MarkerPlacement::new("task")
+                        .with_if_with(vec!["Waiting"])
+                        .with_value("waiting"),
+                ]),
+            )
+            .with_marker("Done", Marker::new("Done").with_placements(vec![]))
+            .with_marker("Waiting", Marker::new("Waiting").with_placements(vec![]))
+            .with_marker("Break", Marker::new("Break").with_placements(vec![]))
+    }
+
+    // --- File name diagnostic ---
+
+    #[test]
+    fn test_valid_file_name_no_diagnostic() {
+        assert!(compute_file_name_diagnostic("20260413-120000_daily.md").is_none());
+        assert!(compute_file_name_diagnostic("20260413-1200_daily.md").is_none());
+        assert!(compute_file_name_diagnostic("20260413-120000 markers.md").is_none());
+        assert!(compute_file_name_diagnostic("20260413 some title.md").is_none());
+    }
+
+    #[test]
+    fn test_invalid_file_name_emits_warning() {
+        let d = compute_file_name_diagnostic("notes.md");
+        assert!(d.is_some());
+        assert_eq!(d.unwrap().severity, Some(DiagnosticSeverity::WARNING));
+    }
+
+    #[test]
+    fn test_non_md_file_no_diagnostic() {
+        assert!(compute_file_name_diagnostic("notes.txt").is_none());
+    }
+
+    // --- Marker extraction ---
+
+    #[test]
+    fn test_extract_markers_from_line() {
+        let markers = extract_markers_from_line("@Task @Done some content @Tag");
+        assert_eq!(markers, vec!["Task", "Done", "Tag"]);
+    }
+
+    #[test]
+    fn test_extract_markers_empty_line() {
+        assert!(extract_markers_from_line("no markers here").is_empty());
+    }
+
+    // --- Marker at position ---
+
+    #[test]
+    fn test_extract_marker_at_position_on_marker() {
+        let line = "some @Task content";
+        // Cursor on 'T' of Task → position 6
+        assert_eq!(
+            extract_marker_at_position(line, 6),
+            Some("Task".to_string())
+        );
+    }
+
+    #[test]
+    fn test_extract_marker_at_position_at_at_sign() {
+        let line = "some @Task content";
+        // Cursor on '@' → position 5
+        assert_eq!(
+            extract_marker_at_position(line, 5),
+            Some("Task".to_string())
+        );
+    }
+
+    #[test]
+    fn test_extract_marker_at_position_on_content() {
+        let line = "some @Task content";
+        // Cursor on 'c' of 'content' (position 11)
+        assert!(extract_marker_at_position(line, 11).is_none());
+    }
+
+    // --- Completions ---
+
+    #[test]
+    fn test_completions_no_at_sign_returns_empty() {
+        let config = make_config();
+        let items = completions_for_line("hello world", 5, &config);
+        assert!(items.is_empty());
+    }
+
+    #[test]
+    fn test_completions_at_sign_returns_all_markers() {
+        let config = make_config();
+        let items = completions_for_line("@", 1, &config);
+        assert!(!items.is_empty());
+        let labels: Vec<&str> = items.iter().map(|i| i.label.as_str()).collect();
+        assert!(labels.contains(&"@Task"));
+        assert!(labels.contains(&"@Done"));
+    }
+
+    #[test]
+    fn test_completions_prefix_filters() {
+        let config = make_config();
+        let items = completions_for_line("@Ta", 3, &config);
+        assert!(items
+            .iter()
+            .all(|i| i.label.starts_with("@Ta") || i.label.starts_with("@ta")));
+        assert!(items.iter().any(|i| i.label == "@Task"));
+    }
+
+    #[test]
+    fn test_completions_conditional_sorted_first() {
+        let config = make_config();
+        // @Task is on the line → Done and Waiting should be conditional suggestions
+        let items = completions_for_line("@Task @", 7, &config);
+        let done = items.iter().find(|i| i.label == "@Done");
+        let waiting = items.iter().find(|i| i.label == "@Waiting");
+        assert!(done.is_some());
+        assert!(waiting.is_some());
+        // Conditional items have sort_text starting with "0_"
+        assert!(done
+            .unwrap()
+            .sort_text
+            .as_deref()
+            .unwrap_or("")
+            .starts_with("0_"));
+    }
+
+    #[test]
+    fn test_completions_temporal_snippet_digit_after_at() {
+        let config = make_config();
+        let items = completions_for_line("@2", 2, &config);
+        assert!(!items.is_empty());
+        let labels: Vec<&str> = items.iter().map(|i| i.label.as_str()).collect();
+        assert!(labels.contains(&"YYYYMMDD"));
+        assert!(labels.contains(&"HHMMSS"));
+        // Temporal items use snippet format
+        assert!(items
+            .iter()
+            .any(|i| i.kind == Some(CompletionItemKind::SNIPPET)));
+    }
+}
diff --git a/src/cli/commands/mod.rs b/src/cli/commands/mod.rs
index e49668b..67a8661 100644
--- a/src/cli/commands/mod.rs
+++ b/src/cli/commands/mod.rs
@@ -12,6 +12,7 @@ use crate::models::{LocalizedShard, RepositoryConfiguration};
 pub mod completions;
 pub mod daily;
 pub mod edit;
+pub mod lsp;
 pub mod new;
 pub mod timesheet;
 pub mod todo;
diff --git a/src/main.rs b/src/main.rs
index 8406385..d543ea5 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -22,6 +22,7 @@ fn main() -> miette::Result<()> {
         Some(Commands::Completions { shell }) => {
             streamd::cli::commands::completions::run(shell);
         }
+        Some(Commands::Lsp) => streamd::cli::commands::lsp::run()?,
         None => streamd::cli::commands::daily::run(None)?,
     }