@@ -20,3 +20,6 @@ clap = { version = "4", features = ["derive"] }
 
 [lints]
 workspace = true
+
+[dev-dependencies]
+tempfile = { workspace = true }
@@ -101,8 +101,9 @@ impl SteeringFiles {
         }
         if !self.user.is_empty() {
             sections.push(format!(
-                "User-level steering files (not project-specific — you should read these \
-                 for the user's global preferences and conventions):\n{}",
+                "User-level steering files (global preferences, not project-specific — \
+                 usually already embedded in your system prompt; load any whose content \
+                 you have not seen):\n{}",
                 self.user.join("\n")
             ));
         }
@@ -170,6 +171,123 @@ fn home_dir() -> Option<PathBuf> {
     std::env::var_os("HOME").map(PathBuf::from)
 }
 
+/// Per-file budget (bytes, cut on a char boundary) for embedding a global
+/// steering file into the system prompt.
+pub const EMBED_PER_FILE_BUDGET: usize = 8 * 1024;
+/// Total budget (bytes) for all embedded global steering files combined.
+/// Kept below the daemon's per-server fragment budget (16 KiB) so the
+/// fragment is never truncated mid-file by the runtime.
+pub const EMBED_TOTAL_BUDGET: usize = 14 * 1024;
+
+/// Whether a global steering file's *content* should be embedded into the
+/// system prompt. Prose instruction files are embedded; structured config
+/// (e.g. `settings.json`) is not — such files are not instructions and may
+/// contain tokens/secrets. Non-embedded files remain discoverable via
+/// `list_steering` / `load_steering`.
+fn is_embeddable(rel: &str) -> bool {
+    !rel.ends_with(".json")
+}
+
+/// Build the system-prompt fragment embedding the user's GLOBAL (home
+/// directory) steering files. Project files are excluded: they depend on a
+/// repository that may not be cloned yet, and remain on the
+/// `list_steering`/`load_steering` flow.
+pub async fn build_global_steering_prompt() -> Option<String> {
+    build_global_steering_prompt_from(&home_dir()?).await
+}
+
+/// [`build_global_steering_prompt`] with an explicit home directory (for
+/// tests).
+///
+/// Files are embedded in sorted path order, each delimited with its `~/`
+/// path. [`EMBED_PER_FILE_BUDGET`] and [`EMBED_TOTAL_BUDGET`] bound the
+/// fragment; truncated or skipped files get a marker telling the agent to
+/// read the rest via `load_steering`. Returns `None` when there is nothing
+/// to embed.
+pub async fn build_global_steering_prompt_from(home: &Path) -> Option<String> {
+    let canon_home = fs::canonicalize(home).await.ok()?;
+
+    let mut seen_canonical = HashSet::new();
+    let mut files: Vec<String> = Vec::new();
+    for rel in collect_candidates(home).await {
+        let abs = home.join(&rel);
+        if !abs.exists() {
+            continue;
+        }
+        let Ok(canonical) = fs::canonicalize(&abs).await else {
+            continue;
+        };
+        if !canonical.starts_with(&canon_home) {
+            continue;
+        }
+        if seen_canonical.insert(canonical) {
+            files.push(rel.to_string_lossy().into_owned());
+        }
+    }
+    files.sort();
+
+    let mut sections: Vec<String> = Vec::new();
+    let mut used = 0usize;
+    let mut deferred: Vec<String> = Vec::new();
+    for rel in &files {
+        if !is_embeddable(rel) {
+            continue;
+        }
+        let Ok(content) = fs::read_to_string(home.join(rel)).await else {
+            continue;
+        };
+        let content = content.trim();
+        if content.is_empty() {
+            continue;
+        }
+        if used >= EMBED_TOTAL_BUDGET {
+            deferred.push(format!("~/{rel}"));
+            continue;
+        }
+        let remaining = (EMBED_TOTAL_BUDGET - used).min(EMBED_PER_FILE_BUDGET);
+        let (body, truncated) = if content.len() > remaining {
+            let mut cut = remaining;
+            while !content.is_char_boundary(cut) {
+                cut -= 1;
+            }
+            (&content[..cut], true)
+        } else {
+            (content, false)
+        };
+        used += body.len();
+        let mut section = format!("### ~/{rel}\n\n{body}");
+        if truncated {
+            section.push_str(&format!(
+                "\n\n[... truncated — read the rest with `load_steering` (path: \"~/{rel}\")]"
+            ));
+        }
+        sections.push(section);
+    }
+
+    if sections.is_empty() {
+        return None;
+    }
+
+    let mut prompt = String::from(
+        "The user's global steering files (apply to ALL projects) are embedded \
+         below. Follow them without being asked. Project-specific steering files \
+         are NOT embedded — discover them with `list_steering` after cloning.\n",
+    );
+    for section in sections {
+        prompt.push('\n');
+        prompt.push_str(&section);
+        prompt.push('\n');
+    }
+    if !deferred.is_empty() {
+        prompt.push_str(&format!(
+            "\nAdditional global steering files did not fit the embedding budget — \
+             read them with `load_steering`: {}\n",
+            deferred.join(", ")
+        ));
+    }
+    Some(prompt)
+}
+
 /// Check that `rel` is under a known steering location.
 fn is_known_steering_location(rel: &str) -> bool {
     let rel_path = Path::new(rel);
@@ -238,7 +356,83 @@ mod tests {
         let rendered = files.render();
         assert!(rendered.contains("Project steering files:\nAGENTS.md"));
         assert!(rendered.contains("not project-specific"));
-        assert!(rendered.contains("you should read these"));
+        assert!(rendered.contains("load any whose content"));
         assert!(rendered.contains("~/INFINITY.md"));
     }
+
+    #[tokio::test]
+    async fn global_prompt_embeds_only_global_prose_files() {
+        let home = tempfile::tempdir().expect("create fake home");
+        std::fs::write(home.path().join("INFINITY.md"), "Global rule: be kind.")
+            .expect("write INFINITY.md");
+        std::fs::create_dir_all(home.path().join(".kiro/steering")).expect("mkdir steering");
+        std::fs::write(
+            home.path().join(".kiro/steering/security.md"),
+            "Never commit secrets.",
+        )
+        .expect("write steering file");
+        std::fs::create_dir_all(home.path().join(".claude")).expect("mkdir .claude");
+        std::fs::write(
+            home.path().join(".claude/settings.json"),
+            r#"{"token": "SECRET"}"#,
+        )
+        .expect("write settings.json");
+
+        let prompt = build_global_steering_prompt_from(home.path())
+            .await
+            .expect("globals exist, prompt builds");
+        assert!(prompt.contains("### ~/INFINITY.md"));
+        assert!(prompt.contains("Global rule: be kind."));
+        assert!(prompt.contains("### ~/.kiro/steering/security.md"));
+        assert!(prompt.contains("Never commit secrets."));
+        // Structured config is never embedded (may hold secrets).
+        assert!(!prompt.contains("settings.json"));
+        assert!(!prompt.contains("SECRET"));
+        // Project discovery guidance is present.
+        assert!(prompt.contains("list_steering"));
+    }
+
+    #[tokio::test]
+    async fn global_prompt_is_none_without_steering_files() {
+        let home = tempfile::tempdir().expect("create fake home");
+        assert_eq!(build_global_steering_prompt_from(home.path()).await, None);
+    }
+
+    #[tokio::test]
+    async fn global_prompt_applies_budgets_with_markers() {
+        let home = tempfile::tempdir().expect("create fake home");
+        // One file over the per-file budget...
+        std::fs::write(
+            home.path().join("INFINITY.md"),
+            "x".repeat(EMBED_PER_FILE_BUDGET + 100),
+        )
+        .expect("write big file");
+        // ...and enough others to blow the total budget.
+        std::fs::create_dir_all(home.path().join(".kiro/steering")).expect("mkdir steering");
+        for i in 0..4 {
+            std::fs::write(
+                home.path().join(format!(".kiro/steering/f{i}.md")),
+                "y".repeat(4 * 1024),
+            )
+            .expect("write filler");
+        }
+
+        let prompt = build_global_steering_prompt_from(home.path())
+            .await
+            .expect("prompt builds");
+        assert!(
+            prompt.contains("[... truncated — read the rest with `load_steering`"),
+            "per-file truncation marker missing"
+        );
+        assert!(
+            prompt.contains("did not fit the embedding budget"),
+            "total-budget deferral note missing"
+        );
+        // The fragment stays under the daemon's 16 KiB per-server budget.
+        assert!(
+            prompt.len() < 16 * 1024,
+            "fragment too large: {}",
+            prompt.len()
+        );
+    }
 }
@@ -26,17 +26,17 @@ struct AppState {
     callback_client: PlainCallbackClient,
 }
 
-fn build_manifest(endpoint: &str) -> ToolsetManifest {
+fn build_manifest(endpoint: &str, system_prompt: Option<String>) -> ToolsetManifest {
     ToolsetManifest {
         name: "steering-tools".to_owned(),
         description: Some("Discover and load project steering files (CLAUDE.md, AGENTS.md, .kiro/steering/, etc.)".to_owned()),
         endpoint: endpoint.to_owned(),
         needs_migration: false,
-        system_prompt: None,
+        system_prompt,
         tools: vec![
             ToolDef {
                 name: "list_steering".to_owned(),
-                description: "List all known steering/instruction files found in a project root. Call this immediately at the start of a session, before doing any other work, so the user's instructions can guide the rest of the task. Scans for CLAUDE.md, AGENTS.md, .kiro/steering/, .cursorrules, .github/copilot-instructions.md, .windsurfrules, CONVENTIONS.md, .cursor/rules/, .ai/rules/, etc. Also scans the user's home directory for user-level (non-project) steering files, returned with a `~/` prefix — these contain the user's global preferences and should generally be loaded. Returns deduplicated relative paths (symlinks resolved).".to_owned(),
+                description: "List all known steering/instruction files found in a project root. Call this immediately after cloning a repository, before doing any other work, so the project's instructions can guide the rest of the task. Scans for CLAUDE.md, AGENTS.md, .kiro/steering/, .cursorrules, .github/copilot-instructions.md, .windsurfrules, CONVENTIONS.md, .cursor/rules/, .ai/rules/, etc. Also lists the user's home-directory steering files with a `~/` prefix — their content is usually already embedded in your system prompt; load any that are not. Returns deduplicated relative paths (symlinks resolved).".to_owned(),
                 input_schema: serde_json::json!({
                     "type": "object",
                     "properties": {
@@ -84,7 +84,13 @@ async fn toolset_handler(headers: HeaderMap) -> Json<ToolsetManifest> {
     } else {
         "https"
     };
-    Json(build_manifest(&format!("{scheme}://{host}/invoke")))
+    // Rebuilt per fetch, so a new session picks up edits to the user's
+    // global steering files without a server restart.
+    let system_prompt = rap_steering_server::build_global_steering_prompt().await;
+    Json(build_manifest(
+        &format!("{scheme}://{host}/invoke"),
+        system_prompt,
+    ))
 }
 
 async fn invoke_handler(