crates/core/src/fragments.rs
Rama main · réplica de lectura del repositorio original.
//! Bounded context-fragment system with hard caps (issue #5264).
//!
//! Every context injection goes through a typed fragment with a
//! `matches_text` recognizer, collected in one `crates/core` module.
//! Hard caps: per-fragment byte cap, 10K-token ceiling, injected-item count.
//! Project-instruction import (#3978, #4079) is a typed fragment.
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
use std::path::{Path, PathBuf};
// Caps
pub const MAX_FRAGMENT_TOKENS: usize = 10_000;
pub const MAX_FRAGMENT_BYTES: usize = MAX_FRAGMENT_TOKENS * 4; // 40_000
pub const DEFAULT_FRAGMENT_MAX_BYTES: usize = 4 * 1024;
pub const MAX_FRAGMENTS_PER_CONTEXT: usize = 16;
pub const INSTRUCTIONS_FILE_MAX_BYTES: usize = 100 * 1024;
pub const MAX_INSTRUCTION_FILES: usize = 32;
/// Stable fragment identities. Markers are public contract.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum FragmentId {
Workspace,
Permissions,
Route,
AgentTopology,
SkillsTools,
TokenBudget,
ProjectInstructions,
Constitution,
}
impl FragmentId {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::Workspace => "workspace",
Self::Permissions => "permissions",
Self::Route => "route",
Self::AgentTopology => "agent_topology",
Self::SkillsTools => "skills_tools",
Self::TokenBudget => "token_budget",
Self::ProjectInstructions => "project_instructions",
Self::Constitution => "constitution",
}
}
#[must_use]
pub fn marker(self) -> &'static str {
match self {
Self::Workspace => "<!-- cw:ctx:workspace -->",
Self::Permissions => "<!-- cw:ctx:permissions -->",
Self::Route => "<!-- cw:ctx:route -->",
Self::AgentTopology => "<!-- cw:ctx:agent_topology -->",
Self::SkillsTools => "<!-- cw:ctx:skills_tools -->",
Self::TokenBudget => "<!-- cw:ctx:token_budget -->",
Self::ProjectInstructions => "<!-- cw:ctx:project_instructions -->",
Self::Constitution => "<!-- cw:ctx:constitution -->",
}
}
#[must_use]
pub fn role(self) -> FragmentRole {
match self {
Self::Workspace => FragmentRole::Workspace,
Self::Permissions => FragmentRole::Permissions,
Self::Route => FragmentRole::Route,
Self::AgentTopology => FragmentRole::AgentTopology,
Self::SkillsTools => FragmentRole::SkillsTools,
Self::TokenBudget => FragmentRole::TokenBudget,
Self::ProjectInstructions => FragmentRole::ProjectInstructions,
Self::Constitution => FragmentRole::Constitution,
}
}
#[must_use]
pub fn all() -> &'static [FragmentId] {
&[
Self::Workspace,
Self::Permissions,
Self::Route,
Self::AgentTopology,
Self::SkillsTools,
Self::TokenBudget,
Self::ProjectInstructions,
Self::Constitution,
]
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum FragmentRole {
Workspace,
Permissions,
Route,
AgentTopology,
SkillsTools,
TokenBudget,
ProjectInstructions,
Constitution,
}
impl FragmentRole {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::Workspace => "workspace",
Self::Permissions => "permissions",
Self::Route => "route",
Self::AgentTopology => "agent_topology",
Self::SkillsTools => "skills_tools",
Self::TokenBudget => "token_budget",
Self::ProjectInstructions => "project_instructions",
Self::Constitution => "constitution",
}
}
}
#[must_use]
pub fn estimate_tokens(text: &str) -> usize {
text.len().div_ceil(4)
}
/// Typed fragment trait with `matches_text` recognizer.
pub trait ContextFragment {
fn fragment_id(&self) -> FragmentId;
fn marker(&self) -> &'static str;
fn content(&self) -> &str;
fn matches_text(&self, haystack: &str) -> bool {
haystack.contains(self.marker())
}
fn tokens_est(&self) -> usize {
estimate_tokens(self.content())
}
fn max_bytes(&self) -> usize;
fn is_within_token_ceiling(&self) -> bool {
self.tokens_est() <= MAX_FRAGMENT_TOKENS
}
fn is_within_byte_ceiling(&self) -> bool {
self.content().len() <= MAX_FRAGMENT_BYTES
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BoundedFragment {
pub id: FragmentId,
pub role: FragmentRole,
pub marker: &'static str,
pub max_bytes: usize,
pub content: String,
pub content_hash: u64,
}
impl BoundedFragment {
#[must_use]
pub fn new(id: FragmentId, raw: impl Into<String>) -> Self {
Self::with_max_bytes(id, raw, DEFAULT_FRAGMENT_MAX_BYTES)
}
#[must_use]
pub fn with_max_bytes(id: FragmentId, raw: impl Into<String>, max_bytes: usize) -> Self {
let clamped_max = max_bytes.min(MAX_FRAGMENT_BYTES);
let mut content = enforce_byte_cap(raw.into(), clamped_max);
if estimate_tokens(&content) > MAX_FRAGMENT_TOKENS {
content = enforce_byte_cap(content, MAX_FRAGMENT_BYTES);
}
let content_hash = hash_content(&content);
Self {
id,
role: id.role(),
marker: id.marker(),
max_bytes: clamped_max,
content,
content_hash,
}
}
#[must_use]
pub fn project_instructions(raw: impl Into<String>) -> Self {
Self::with_max_bytes(FragmentId::ProjectInstructions, raw, MAX_FRAGMENT_BYTES)
}
#[must_use]
pub fn constitution(raw: impl Into<String>) -> Self {
Self::with_max_bytes(FragmentId::Constitution, raw, MAX_FRAGMENT_BYTES)
}
#[must_use]
pub fn render_marked(&self) -> String {
format!("{}\n{}", self.marker, self.content.trim_end())
}
}
impl ContextFragment for BoundedFragment {
fn fragment_id(&self) -> FragmentId {
self.id
}
fn marker(&self) -> &'static str {
self.marker
}
fn content(&self) -> &str {
&self.content
}
fn max_bytes(&self) -> usize {
self.max_bytes
}
}
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub enum FragmentCapError {
#[error("fragment {id:?} exceeds 10K-token ceiling: {tokens} tokens ({bytes} bytes)")]
TokenCeiling {
id: FragmentId,
tokens: usize,
bytes: usize,
},
#[error("fragment {id:?} exceeds byte ceiling: {bytes} > {max} bytes")]
ByteCeiling {
id: FragmentId,
bytes: usize,
max: usize,
},
#[error("context has too many fragments: {count} > {max}")]
TooManyFragments { count: usize, max: usize },
}
pub fn validate_fragment(fragment: &BoundedFragment) -> Result<(), FragmentCapError> {
if fragment.content.len() > MAX_FRAGMENT_BYTES {
return Err(FragmentCapError::ByteCeiling {
id: fragment.id,
bytes: fragment.content.len(),
max: MAX_FRAGMENT_BYTES,
});
}
let tokens = estimate_tokens(&fragment.content);
if tokens > MAX_FRAGMENT_TOKENS {
return Err(FragmentCapError::TokenCeiling {
id: fragment.id,
bytes: fragment.content.len(),
tokens,
});
}
Ok(())
}
pub fn validate_fragment_set(fragments: &[BoundedFragment]) -> Result<(), FragmentCapError> {
if fragments.len() > MAX_FRAGMENTS_PER_CONTEXT {
return Err(FragmentCapError::TooManyFragments {
count: fragments.len(),
max: MAX_FRAGMENTS_PER_CONTEXT,
});
}
for f in fragments {
validate_fragment(f)?;
}
Ok(())
}
// Project-instruction import (#3978)
pub const PROJECT_INSTRUCTION_CANDIDATES: &[&str] = &[
"AGENTS.md",
".agents/AGENTS.md",
"CLAUDE.md",
".claude/instructions.md",
".codewhale/instructions.md",
".deepseek/instructions.md",
".cursorrules",
".cursor/rules",
".clinerules",
".windsurf/rules",
".gemini",
".github/copilot-instructions.md",
".github/muse-instructions.md",
];
/// Workspace instruction formats not already owned by Codewhale's canonical
/// project-context loader. The TUI uses this subset to avoid injecting
/// `AGENTS.md` / `CLAUDE.md` / `instructions.md` twice while still importing
/// additional agent rule formats through the typed fragment boundary.
pub const ADDITIONAL_PROJECT_INSTRUCTION_CANDIDATES: &[&str] = &[
".agents/AGENTS.md",
".cursorrules",
".cursor/rules",
".clinerules",
".windsurf/rules",
".gemini",
".github/copilot-instructions.md",
".github/muse-instructions.md",
];
fn is_symlink(p: &Path) -> bool {
std::fs::symlink_metadata(p)
.map(|m| m.file_type().is_symlink())
.unwrap_or(false)
}
pub fn read_project_instruction_file(file: std::fs::File) -> Option<String> {
let meta = file.metadata().ok()?;
if !meta.is_file() {
return None;
}
use std::io::Read as _;
let mut buf = Vec::new();
file.take(INSTRUCTIONS_FILE_MAX_BYTES as u64 + 1)
.read_to_end(&mut buf)
.ok()?;
let observed_len = buf.len() as u64;
if meta.len().max(observed_len) > INSTRUCTIONS_FILE_MAX_BYTES as u64 {
buf.truncate(INSTRUCTIONS_FILE_MAX_BYTES);
let mut text = String::from_utf8_lossy(&buf).into_owned();
let mut end = INSTRUCTIONS_FILE_MAX_BYTES.min(text.len());
while end > 0 && !text.is_char_boundary(end) {
end -= 1;
}
text.truncate(end);
let omitted = meta
.len()
.max(observed_len)
.saturating_sub(INSTRUCTIONS_FILE_MAX_BYTES as u64);
text.push_str(&format!("\n[…truncated: {omitted} bytes omitted]"));
return Some(text);
}
let raw = String::from_utf8(buf).ok()?;
let trimmed = raw.trim();
if trimmed.is_empty() {
None
} else {
Some(trimmed.to_string())
}
}
fn collect_candidate_files(workspace: &Path, candidates: &[&str]) -> Vec<PathBuf> {
let mut files = Vec::new();
for candidate in candidates {
let path = workspace.join(candidate);
// `is_dir()` follows symlinks, so a symlinked `.cursor/rules` pointing
// outside the workspace used to be traversed: every file behind it is a
// real file, so the per-entry symlink checks below all passed and the
// escape succeeded. `project_context.rs` already refuses symlinked
// rules directories for exactly this reason; the two loaders now agree.
if path.is_dir() && !is_symlink(&path) {
let mut dir_files = Vec::new();
if let Ok(entries) = std::fs::read_dir(&path) {
for e in entries.flatten() {
let p = e.path();
if p.is_file() && p.extension().is_some_and(|e| e == "md") && !is_symlink(&p) {
dir_files.push(p);
}
}
}
if let Ok(entries) = std::fs::read_dir(&path) {
for e in entries.flatten() {
let p = e.path();
if p.is_dir()
&& !is_symlink(&p)
&& let Ok(sub) = std::fs::read_dir(&p)
{
for se in sub.flatten() {
let sp = se.path();
if sp.is_file()
&& sp.extension().is_some_and(|e| e == "md")
&& !is_symlink(&sp)
{
dir_files.push(sp);
}
}
}
}
}
dir_files.sort();
let remaining = MAX_INSTRUCTION_FILES.saturating_sub(files.len());
dir_files.truncate(remaining);
files.extend(dir_files);
} else if path.is_file() && !is_symlink(&path) {
files.push(path);
}
if files.len() >= MAX_INSTRUCTION_FILES {
break;
}
}
files.truncate(MAX_INSTRUCTION_FILES);
files.sort();
files.dedup();
files
}
/// Enumerate the safe, bounded file paths selected for a caller-provided set
/// of project-instruction candidates.
///
/// This is the same traversal used by
/// [`load_selected_project_instruction_fragment`]. Callers that cache the
/// loader's result can fingerprint these paths without maintaining a second,
/// subtly different directory walk. Content validation still happens in the
/// loader: an empty, unreadable, or non-UTF-8 file may be selected here and
/// then contribute no fragment.
#[must_use]
pub fn selected_project_instruction_candidate_files(
workspace: &Path,
candidates: &[&str],
) -> Vec<PathBuf> {
collect_candidate_files(workspace, candidates)
}
fn load_project_instruction_fragment_from_candidates(
workspace: &Path,
candidates: &[&str],
mut opener: impl FnMut(&Path) -> std::io::Result<std::fs::File>,
) -> Option<BoundedFragment> {
let files = collect_candidate_files(workspace, candidates);
if files.is_empty() {
return None;
}
let mut sections = Vec::new();
for path in files {
if let Some(content) = opener(&path).ok().and_then(read_project_instruction_file) {
let rel = path
.strip_prefix(workspace)
.unwrap_or(&path)
.display()
.to_string();
sections.push(format!(
"<project_instructions source=\"{rel}\">\n{content}\n</project_instructions>"
));
}
}
if sections.is_empty() {
return None;
}
let merged = sections.join("\n\n");
let fragment = BoundedFragment::project_instructions(merged);
debug_assert!(validate_fragment(&fragment).is_ok());
Some(fragment)
}
pub fn load_project_instruction_fragment(workspace: &Path) -> Option<BoundedFragment> {
load_project_instruction_fragment_from_candidates(
workspace,
PROJECT_INSTRUCTION_CANDIDATES,
|path| std::fs::File::open(path),
)
}
/// Load only instruction formats that the canonical TUI project-context path
/// does not already render. This prevents duplicate authority while retaining
/// the broader compatibility import added by the bounded fragment system.
///
/// Prefer [`load_selected_project_instruction_fragment`]: importing every
/// foreign format unconditionally makes another tool's instruction file
/// standing authority here without anyone asking for it.
pub fn load_additional_project_instruction_fragment(workspace: &Path) -> Option<BoundedFragment> {
load_project_instruction_fragment_from_candidates(
workspace,
ADDITIONAL_PROJECT_INSTRUCTION_CANDIDATES,
|path| std::fs::File::open(path),
)
}
/// Load exactly the instruction candidates the caller names.
///
/// The caller owns the opt-in decision; an empty list imports nothing and
/// yields `None` rather than silently falling back to the full candidate set.
pub fn load_selected_project_instruction_fragment(
workspace: &Path,
candidates: &[&str],
) -> Option<BoundedFragment> {
load_selected_project_instruction_fragment_with_reader(workspace, candidates, |path| {
std::fs::File::open(path)
})
}
pub fn load_selected_project_instruction_fragment_with_reader(
workspace: &Path,
candidates: &[&str],
opener: impl FnMut(&Path) -> std::io::Result<std::fs::File>,
) -> Option<BoundedFragment> {
if candidates.is_empty() {
return None;
}
load_project_instruction_fragment_from_candidates(workspace, candidates, opener)
}
pub fn project_instructions_from_sources(
sources: impl IntoIterator<Item = (String, String)>,
) -> Option<BoundedFragment> {
let mut sections = Vec::new();
for (name, content) in sources {
let trimmed = content.trim();
if trimmed.is_empty() {
continue;
}
let body = if trimmed.len() > INSTRUCTIONS_FILE_MAX_BYTES {
let mut end = INSTRUCTIONS_FILE_MAX_BYTES;
while end > 0 && !trimmed.is_char_boundary(end) {
end -= 1;
}
let omitted = trimmed.len() - end;
format!("{}\n[…truncated: {omitted} bytes omitted]", &trimmed[..end])
} else {
trimmed.to_string()
};
sections.push(format!(
"<project_instructions source=\"{name}\">\n{body}\n</project_instructions>"
));
if sections.len() >= MAX_INSTRUCTION_FILES {
break;
}
}
if sections.is_empty() {
return None;
}
Some(BoundedFragment::project_instructions(sections.join("\n\n")))
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct FragmentBudgetSnapshot {
pub fragment_ids: Vec<String>,
pub fragment_markers: Vec<String>,
pub max_fragment_bytes: usize,
pub max_fragment_tokens: usize,
pub default_fragment_max_bytes: usize,
pub max_fragments_per_context: usize,
pub instructions_file_max_bytes: usize,
pub max_instruction_files: usize,
pub project_instruction_candidates: Vec<String>,
}
#[must_use]
pub fn fragment_budget_snapshot() -> FragmentBudgetSnapshot {
FragmentBudgetSnapshot {
fragment_ids: FragmentId::all()
.iter()
.map(|id| id.as_str().to_string())
.collect(),
fragment_markers: FragmentId::all()
.iter()
.map(|id| id.marker().to_string())
.collect(),
max_fragment_bytes: MAX_FRAGMENT_BYTES,
max_fragment_tokens: MAX_FRAGMENT_TOKENS,
default_fragment_max_bytes: DEFAULT_FRAGMENT_MAX_BYTES,
max_fragments_per_context: MAX_FRAGMENTS_PER_CONTEXT,
instructions_file_max_bytes: INSTRUCTIONS_FILE_MAX_BYTES,
max_instruction_files: MAX_INSTRUCTION_FILES,
project_instruction_candidates: PROJECT_INSTRUCTION_CANDIDATES
.iter()
.map(|s| s.to_string())
.collect(),
}
}
fn hash_content(content: &str) -> u64 {
let mut hasher = DefaultHasher::new();
content.hash(&mut hasher);
hasher.finish()
}
fn enforce_byte_cap(raw: String, max_bytes: usize) -> String {
if max_bytes == 0 {
return String::new();
}
if raw.len() <= max_bytes {
return raw;
}
let omitted = raw.len().saturating_sub(max_bytes);
let marker = format!("\n[…truncated: {omitted} bytes omitted]");
if marker.len() >= max_bytes {
return marker.chars().take(max_bytes).collect();
}
let keep = max_bytes.saturating_sub(marker.len());
let mut end = keep;
while end > 0 && !raw.is_char_boundary(end) {
end -= 1;
}
let mut out = raw[..end].to_string();
out.push_str(&marker);
out
}
#[cfg(test)]
mod tests {
use super::*;
use std::fs;
use tempfile::tempdir;
#[test]
fn fragment_has_matches_text_recognizer() {
let fragment = BoundedFragment::new(FragmentId::Workspace, "repo: /tmp/demo");
let rendered = fragment.render_marked();
assert!(fragment.matches_text(&rendered));
assert!(!fragment.matches_text("no marker here"));
assert_eq!(FragmentId::Workspace.marker(), "<!-- cw:ctx:workspace -->");
assert_eq!(
FragmentId::ProjectInstructions.marker(),
"<!-- cw:ctx:project_instructions -->"
);
assert_eq!(
FragmentId::Constitution.marker(),
"<!-- cw:ctx:constitution -->"
);
}
#[test]
fn all_fragment_types_go_through_bounded_module() {
for id in FragmentId::all() {
let fragment = BoundedFragment::new(*id, "hello");
assert_eq!(fragment.marker, id.marker());
assert_eq!(fragment.id, *id);
validate_fragment(&fragment).expect("small fragment must pass caps");
assert!(fragment.is_within_token_ceiling());
assert!(fragment.is_within_byte_ceiling());
}
}
#[test]
fn per_fragment_byte_cap_truncates_with_marker() {
let oversized = "x".repeat(DEFAULT_FRAGMENT_MAX_BYTES + 64);
let fragment = BoundedFragment::new(FragmentId::AgentTopology, oversized);
assert!(fragment.content.len() <= DEFAULT_FRAGMENT_MAX_BYTES);
assert!(fragment.content.contains("[…truncated:"));
validate_fragment(&fragment).expect("truncated fragment must pass caps");
}
#[test]
fn ten_k_token_ceiling_is_enforced() {
let huge = "a".repeat(MAX_FRAGMENT_BYTES + 1_000);
let fragment = BoundedFragment::project_instructions(huge);
assert!(fragment.content.len() <= MAX_FRAGMENT_BYTES);
assert!(estimate_tokens(&fragment.content) <= MAX_FRAGMENT_TOKENS);
validate_fragment(&fragment).expect("capped fragment must satisfy token ceiling");
let also_huge = "b".repeat(MAX_FRAGMENT_BYTES + 5000);
let fragment = BoundedFragment::with_max_bytes(FragmentId::Workspace, also_huge, 100_000);
assert!(fragment.max_bytes <= MAX_FRAGMENT_BYTES);
assert!(fragment.content.len() <= MAX_FRAGMENT_BYTES);
assert!(fragment.is_within_token_ceiling());
}
#[test]
fn injected_item_count_cap_is_enforced() {
let fragments: Vec<BoundedFragment> = (0..MAX_FRAGMENTS_PER_CONTEXT)
.map(|i| BoundedFragment::new(FragmentId::Workspace, format!("item {i}")))
.collect();
validate_fragment_set(&fragments).expect("exactly MAX_FRAGMENTS must pass");
let mut too_many = fragments.clone();
too_many.push(BoundedFragment::new(FragmentId::Route, "one too many"));
let err = validate_fragment_set(&too_many).expect_err("one over cap must fail");
assert!(matches!(err, FragmentCapError::TooManyFragments { .. }));
}
#[test]
#[cfg(unix)]
fn symlinked_candidate_directory_cannot_escape_the_workspace() {
// `Path::is_dir()` follows symlinks, so a symlinked candidate dir used
// to be traversed: every file behind it is a real file, so the
// per-entry symlink checks passed and content outside the workspace was
// imported as project instruction authority.
let outside = tempdir().expect("outside");
fs::write(outside.path().join("leaked.md"), "SECRET-OUTSIDE-WORKSPACE")
.expect("write outside");
let dir = tempdir().expect("workspace");
let ws = dir.path();
fs::create_dir_all(ws.join(".cursor")).expect("mkdir .cursor");
std::os::unix::fs::symlink(outside.path(), ws.join(".cursor").join("rules"))
.expect("symlink rules dir");
let fragment = load_selected_project_instruction_fragment(ws, &[".cursor/rules"]);
assert!(
fragment.is_none(),
"a symlinked candidate directory must not be traversed: {fragment:?}"
);
}
#[test]
fn selected_candidates_import_nothing_when_the_list_is_empty() {
let dir = tempdir().expect("tempdir");
let ws = dir.path();
fs::write(ws.join(".cursorrules"), "cursor: always use tabs").expect("write cursor");
assert!(
load_selected_project_instruction_fragment(ws, &[]).is_none(),
"an empty opt-in list must import nothing, not fall back to every format"
);
assert!(
load_selected_project_instruction_fragment(ws, &[".cursorrules"]).is_some(),
"an explicitly named candidate is still imported"
);
}
#[test]
fn project_instruction_import_is_a_typed_fragment() {
let dir = tempdir().expect("tempdir");
let ws = dir.path();
fs::write(ws.join(".cursorrules"), "cursor: always use tabs").expect("write cursor");
fs::write(ws.join(".clinerules"), "cline: prefer functional style").expect("write cline");
fs::create_dir_all(ws.join(".windsurf").join("rules")).expect("mkdir windsurf");
fs::write(
ws.join(".windsurf").join("rules").join("extra.md"),
"# windsurf extra",
)
.expect("write windsurf");
fs::create_dir_all(ws.join(".github")).expect("mkdir github");
fs::write(
ws.join(".github").join("copilot-instructions.md"),
"# copilot says hello",
)
.expect("write copilot");
let fragment =
load_project_instruction_fragment(ws).expect("must find imported instructions");
assert_eq!(fragment.id, FragmentId::ProjectInstructions);
assert!(fragment.matches_text(&fragment.render_marked()));
assert!(
fragment.content.contains(".cursorrules") || fragment.content.contains(".clinerules")
);
validate_fragment(&fragment).expect("project-instructions fragment must satisfy caps");
let from_sources = project_instructions_from_sources(vec![
("AGENTS.md".to_string(), "# AGENTS\nbe helpful".to_string()),
(
".cursorrules".to_string(),
"cursor: do the thing".to_string(),
),
])
.expect("sources");
assert_eq!(from_sources.id, FragmentId::ProjectInstructions);
assert!(from_sources.content.contains("AGENTS.md"));
assert!(from_sources.content.contains(".cursorrules"));
validate_fragment(&from_sources).expect("explicit sources must also satisfy caps");
}
#[test]
fn additional_project_instruction_import_does_not_duplicate_canonical_authority() {
let dir = tempdir().expect("tempdir");
let ws = dir.path();
fs::write(ws.join("AGENTS.md"), "canonical authority marker").expect("write agents");
assert!(
load_additional_project_instruction_fragment(ws).is_none(),
"AGENTS.md is already owned by the canonical project-context loader"
);
fs::write(ws.join(".cursorrules"), "additional cursor marker").expect("write cursor rules");
let additional = load_additional_project_instruction_fragment(ws)
.expect("additional rules must produce a typed fragment");
assert!(additional.content.contains("additional cursor marker"));
assert!(!additional.content.contains("canonical authority marker"));
let complete = load_project_instruction_fragment(ws)
.expect("complete importer must retain every supported source");
assert!(complete.content.contains("canonical authority marker"));
assert!(complete.content.contains("additional cursor marker"));
}
#[test]
fn fragment_budget_snapshot_is_stable() {
let snap = fragment_budget_snapshot();
assert_eq!(snap.max_fragment_tokens, 10_000);
assert_eq!(snap.max_fragment_bytes, 40_000);
assert_eq!(snap.max_fragments_per_context, 16);
assert_eq!(snap.default_fragment_max_bytes, 4 * 1024);
assert!(
snap.fragment_ids
.contains(&"project_instructions".to_string())
);
assert!(snap.fragment_ids.contains(&"constitution".to_string()));
assert!(
snap.project_instruction_candidates
.contains(&".cursorrules".to_string())
);
assert!(
snap.project_instruction_candidates
.contains(&".github/copilot-instructions.md".to_string())
);
assert!(
snap.fragment_markers
.contains(&"<!-- cw:ctx:project_instructions -->".to_string())
);
}
}