use std::collections::BTreeMap;
use std::io::{Read, Write};
use std::path::{Path, PathBuf};
use serde::Deserialize;
use serde_json::{json, Value};
use super::args::{NativeHookHarness, ProjectScopeConfig};
use super::consolidate::{dirty_region_size, run_consolidate, ConsolidateOptions, MIN_REGION};
use super::memory_md::{read_project_scope, refresh_memory_md_with_health, MemoryMdOptions};
use super::paths::absolutize_project_dir;
use super::provenance::capture_execution_context;
use crate::error::{MemdError, Result};
use crate::store::{Store, TenantManager};
use crate::task_memory::ExecutionContext;
use crate::types::{ProjectId, TenantId};
const MAX_AUTO_ID_LEN: usize = 64;
const MAX_NATIVE_HOOK_BYTES: u64 = 64 * 1024;
#[derive(Debug, Deserialize)]
struct NativeHookPayload {
#[serde(default)]
cwd: Option<String>,
#[serde(default)]
session_id: Option<String>,
#[serde(default)]
thread_id: Option<String>,
#[serde(default)]
agent_id: Option<String>,
#[serde(default)]
parent_agent_id: Option<String>,
#[serde(default)]
model: Option<String>,
}
#[derive(Debug, Clone)]
pub(super) struct SessionStartOptions {
pub(super) project_dir: PathBuf,
}
#[derive(Debug, Clone)]
pub(super) struct AutoScopeInputs {
pub(super) default_tenant: String,
pub(super) enabled: bool,
}
impl AutoScopeInputs {
pub(super) fn from_env() -> Self {
let raw_tenant = std::env::var("MEMD_DEFAULT_TENANT")
.ok()
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.or_else(|| {
std::env::var("USER")
.ok()
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
})
.unwrap_or_else(|| "default".to_string());
let sanitized = sanitize_id(&raw_tenant, "default");
let default_tenant = if TenantId::validate(&sanitized).is_ok() {
sanitized
} else {
"default".to_string()
};
let enabled = std::env::var("MEMD_AUTO_SCOPE")
.map(|v| v != "0" && !v.eq_ignore_ascii_case("false"))
.unwrap_or(true);
Self {
default_tenant,
enabled,
}
}
}
pub(super) async fn run_session_start<S: Store>(
store: &S,
options: SessionStartOptions,
execution_context: Option<ExecutionContext>,
) -> Result<Value> {
let mut result = run_session_start_inner(store, options, AutoScopeInputs::from_env()).await?;
if let Some(execution_context) = execution_context {
let result_object = result.as_object_mut().ok_or_else(|| {
MemdError::ProtocolError("session-start result must be a JSON object".to_string())
})?;
result_object.insert(
"execution_context".to_string(),
serde_json::to_value(execution_context)?,
);
}
Ok(result)
}
pub(super) fn read_native_hook_context(
harness: NativeHookHarness,
project_dir: &Path,
) -> Result<ExecutionContext> {
let stdin = std::io::stdin();
parse_native_hook_context(harness, stdin.lock(), project_dir)
}
pub(super) fn native_hook_project_dir(requested: &Path, context: &ExecutionContext) -> PathBuf {
if requested != Path::new(".") {
return requested.to_path_buf();
}
context
.cwd
.as_deref()
.filter(|cwd| !cwd.trim().is_empty())
.map(PathBuf::from)
.unwrap_or_else(|| requested.to_path_buf())
}
fn parse_native_hook_context(
harness: NativeHookHarness,
reader: impl Read,
project_dir: &Path,
) -> Result<ExecutionContext> {
let payload = read_bounded_hook_payload(reader)?;
let payload: NativeHookPayload = serde_json::from_slice(&payload)?;
let cwd = nonempty(payload.cwd)
.map(PathBuf::from)
.map(|path| {
if path.is_absolute() {
path
} else {
project_dir.join(path)
}
})
.unwrap_or_else(|| project_dir.to_path_buf());
let mut context = capture_execution_context(&cwd);
let harness_name = match harness {
NativeHookHarness::Claude => "claude",
NativeHookHarness::Codex => "codex",
};
if context.harness.as_deref() != Some(harness_name) {
context.native_session_id = None;
context.native_thread_id = None;
}
context.harness = Some(harness_name.to_string());
if let Some(model) = nonempty(payload.model) {
context.model = Some(model);
}
if let Some(agent_id) = nonempty(payload.agent_id) {
context.native_agent_id = Some(agent_id);
}
if let Some(parent_id) = nonempty(payload.parent_agent_id) {
context.native_parent_id = Some(parent_id);
}
if let Some(session_id) = nonempty(payload.session_id) {
context.native_session_id = Some(session_id);
}
if let Some(thread_id) = nonempty(payload.thread_id) {
context.native_thread_id = Some(thread_id);
}
Ok(context)
}
fn read_bounded_hook_payload(reader: impl Read) -> Result<Vec<u8>> {
let mut payload = Vec::new();
reader
.take(MAX_NATIVE_HOOK_BYTES + 1)
.read_to_end(&mut payload)?;
if payload.len() as u64 > MAX_NATIVE_HOOK_BYTES {
return Err(MemdError::ValidationError(format!(
"native hook payload exceeds {MAX_NATIVE_HOOK_BYTES} bytes"
)));
}
Ok(payload)
}
fn nonempty(value: Option<String>) -> Option<String> {
value
.map(|value| value.trim().to_string())
.filter(|value| !value.is_empty())
}
pub(super) async fn run_session_start_inner<S: Store>(
store: &S,
options: SessionStartOptions,
auto_inputs: AutoScopeInputs,
) -> Result<Value> {
let project_dir = absolutize_project_dir(&options.project_dir)?;
if project_dir.join(".memd-skip").exists() {
return Ok(json!({ "skipped": "memd_skip_present" }));
}
let scope_path = project_dir.join(".memd").join("project_scope.json");
let mut resolved_scope = match validated_project_scope(&project_dir) {
Ok(scope) => scope.map(|scope| (scope.tenant_id, scope.project_id)),
Err(error) => return Ok(invalid_scope_response(&scope_path, &error)),
};
if resolved_scope.is_none() {
let legacy_path = project_dir.join(".memd/config.json");
match read_legacy_scope(&legacy_path) {
Ok(scope) => resolved_scope = scope,
Err(error) => return Ok(invalid_scope_response(&legacy_path, &error)),
}
}
let mut auto_scoped = false;
if resolved_scope.is_none() {
match maybe_auto_create_scope(&project_dir, &auto_inputs)? {
AutoScopeOutcome::Created => {
auto_scoped = true;
}
AutoScopeOutcome::AlreadyExists => {}
AutoScopeOutcome::SkippedDisabled => {
return Ok(json!({ "skipped": "auto_scope_disabled" }));
}
AutoScopeOutcome::SkippedMarker => {
return Ok(json!({ "skipped": "memd_skip_present" }));
}
}
resolved_scope = match validated_project_scope(&project_dir) {
Ok(scope) => scope.map(|scope| (scope.tenant_id, scope.project_id)),
Err(error) => return Ok(invalid_scope_response(&scope_path, &error)),
};
}
let (tenant_id, project_id) = match resolved_scope {
Some(scope) => scope,
None => return Ok(json!({ "skipped": "no_scope" })),
};
let consolidation_recovery = if let Some(persistent) = store.as_persistent() {
let recovery_result = if persistent.is_read_only() {
match persistent.open_consolidation_recovery_writer() {
Ok(writer) => {
crate::consolidate::service::recover_consolidation_runs(&writer, 100).await
}
Err(error) => Err(error),
}
} else {
crate::consolidate::service::recover_consolidation_runs(persistent, 100).await
};
match recovery_result {
Ok(recovery) => {
let mut index_refresh_errors = Vec::new();
if persistent.is_read_only() {
let mut by_tenant = BTreeMap::<String, (TenantId, Vec<_>)>::new();
for (promoted_tenant, chunk_id) in &recovery.promoted_chunks {
by_tenant
.entry(promoted_tenant.to_string())
.or_insert_with(|| (promoted_tenant.clone(), Vec::new()))
.1
.push(chunk_id.clone());
}
for (_, (promoted_tenant, chunk_ids)) in by_tenant {
if let Err(error) = persistent
.refresh_promoted_chunks_in_memory(&promoted_tenant, &chunk_ids)
.await
{
index_refresh_errors.push(error.to_string());
}
}
}
json!({
"inspected": recovery.inspected,
"committed": recovery.committed,
"rolled_back": recovery.rolled_back,
"rejected": recovery.rejected,
"failed_recoverable": recovery.failed_recoverable,
"index_refresh_errors": index_refresh_errors,
})
}
Err(error) => json!({ "error": error.to_string() }),
}
} else {
json!({ "skipped": "non_persistent_store" })
};
let tenant_manager = store
.as_persistent()
.map(|persistent| TenantManager::new(persistent.data_dir().to_path_buf()));
let memory_md = refresh_memory_md_with_health(
store,
tenant_manager.as_ref(),
MemoryMdOptions {
tenant_id: Some(tenant_id.clone()),
project_id: project_id.clone(),
project_dir: project_dir.clone(),
output: PathBuf::from("memory.md"),
project_limit: 10,
global_limit: 2,
candidate_k: 40,
explain_output: None,
},
)
.await?;
let dirty = dirty_region_size(
store,
&project_dir,
Some(tenant_id.clone()),
project_id.clone(),
)
.await
.unwrap_or(0);
let mut consolidation_spawned = false;
let mut skip_reason: Option<String> = None;
if dirty >= MIN_REGION {
match crate::consolidate::select::select_consolidator() {
Ok(_) => {
let spawn = run_consolidate(
store,
ConsolidateOptions {
tenant_id: Some(tenant_id),
project_id,
project_dir: project_dir.clone(),
max_region: 50,
dry_run: false,
background: true,
force: false,
promote: false,
legacy_immediate: false,
},
)
.await;
consolidation_spawned = spawn
.as_ref()
.ok()
.and_then(|v| v.get("spawned_background").and_then(Value::as_bool))
.unwrap_or(false);
if !consolidation_spawned {
skip_reason = match spawn.as_ref() {
Ok(value) => value
.get("skipped")
.and_then(Value::as_str)
.map(str::to_string),
Err(e) => Some(format!("spawn failed: {e}")),
};
}
}
Err(e) => {
skip_reason = Some(format!("no consolidator backend: {e}"));
}
}
}
Ok(json!({
"memory_md": memory_md,
"dirty_count": dirty,
"consolidation_spawned": consolidation_spawned,
"consolidation_skipped": skip_reason,
"auto_scoped": auto_scoped,
"consolidation_recovery": consolidation_recovery,
}))
}
fn validated_project_scope(project_dir: &Path) -> Result<Option<ProjectScopeConfig>> {
let scope = read_project_scope(project_dir)?;
if let Some(scope) = &scope {
TenantId::validate(&scope.tenant_id)?;
ProjectId::validate_opt(scope.project_id.as_deref())?;
}
Ok(scope)
}
#[derive(Deserialize)]
struct LegacyScopeConfig {
#[serde(default)]
tenant_id: Option<String>,
#[serde(default)]
project_id: Option<String>,
}
fn read_legacy_scope(path: &Path) -> Result<Option<(String, Option<String>)>> {
let text = match std::fs::read_to_string(path) {
Ok(text) => text,
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
match std::fs::symlink_metadata(path) {
Err(metadata_error) if metadata_error.kind() == std::io::ErrorKind::NotFound => {
return Ok(None)
}
Ok(_) => {
return Err(crate::error::MemdError::ValidationError(format!(
"unable to read {}: {error}",
path.display()
)))
}
Err(metadata_error) => {
return Err(crate::error::MemdError::ValidationError(format!(
"unable to inspect {} after read failure ({error}): {metadata_error}",
path.display()
)))
}
}
}
Err(error) => {
return Err(crate::error::MemdError::ValidationError(format!(
"unable to read {}: {error}",
path.display()
)))
}
};
let scope: LegacyScopeConfig = serde_json::from_str(&text).map_err(|error| {
crate::error::MemdError::ValidationError(format!(
"failed to parse {}: {error}",
path.display()
))
})?;
if scope.tenant_id.is_none() && scope.project_id.is_none() {
return Ok(None);
}
let tenant_id = scope.tenant_id.ok_or_else(|| {
crate::error::MemdError::ValidationError(format!("{} is missing tenant_id", path.display()))
})?;
TenantId::validate(&tenant_id)?;
ProjectId::validate_opt(scope.project_id.as_deref())?;
Ok(Some((tenant_id, scope.project_id)))
}
fn invalid_scope_response(path: &Path, error: &crate::error::MemdError) -> Value {
json!({
"skipped": "invalid_project_scope",
"project_scope": path,
"diagnostic": format!(
"existing scope file was preserved because it is invalid or unreadable: {error}"
),
})
}
#[derive(Debug, PartialEq, Eq)]
pub(super) enum AutoScopeOutcome {
Created,
AlreadyExists,
SkippedDisabled,
SkippedMarker,
}
pub(super) fn maybe_auto_create_scope(
project_dir: &Path,
inputs: &AutoScopeInputs,
) -> Result<AutoScopeOutcome> {
if !inputs.enabled {
return Ok(AutoScopeOutcome::SkippedDisabled);
}
if project_dir.join(".memd-skip").exists() {
return Ok(AutoScopeOutcome::SkippedMarker);
}
let project_id = derive_project_id(project_dir);
let scope = ProjectScopeConfig {
tenant_id: inputs.default_tenant.clone(),
project_id: Some(project_id),
interface: "cli".to_string(),
cli_command: "memd".to_string(),
agent_context_output: ".memd/context.md".to_string(),
project_dir: project_dir.display().to_string(),
};
let memd_dir = project_dir.join(".memd");
std::fs::create_dir_all(&memd_dir)?;
let path = memd_dir.join("project_scope.json");
let serialized = format!("{}\n", serde_json::to_string_pretty(&scope)?);
let mut file = match std::fs::OpenOptions::new()
.write(true)
.create_new(true)
.open(&path)
{
Ok(file) => file,
Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => {
return Ok(AutoScopeOutcome::AlreadyExists);
}
Err(error) => return Err(error.into()),
};
if let Err(error) = file.write_all(serialized.as_bytes()) {
drop(file);
let _ = std::fs::remove_file(&path);
return Err(error.into());
}
Ok(AutoScopeOutcome::Created)
}
fn derive_project_id(project_dir: &Path) -> String {
let main_checkout = main_checkout_of_linked_worktree(project_dir);
let raw = main_checkout
.as_deref()
.unwrap_or(project_dir)
.file_name()
.and_then(|n| n.to_str())
.unwrap_or("");
sanitize_id(raw, "project")
}
fn main_checkout_of_linked_worktree(project_dir: &Path) -> Option<PathBuf> {
let dot_git = project_dir.join(".git");
if !dot_git.is_file() {
return None;
}
let pointer = std::fs::read_to_string(&dot_git).ok()?;
let gitdir = pointer
.lines()
.find_map(|line| line.strip_prefix("gitdir:"))?;
let admin_dir = project_dir.join(gitdir.trim());
let commondir = std::fs::read_to_string(admin_dir.join("commondir")).ok()?;
let common_dir = admin_dir.join(commondir.trim()).canonicalize().ok()?;
if common_dir.file_name()? != ".git" {
return None;
}
common_dir.parent().map(Path::to_path_buf)
}
fn sanitize_id(raw: &str, fallback: &str) -> String {
let mut out = String::with_capacity(raw.len().min(MAX_AUTO_ID_LEN));
let mut last_underscore = false;
for ch in raw.chars() {
if out.len() >= MAX_AUTO_ID_LEN {
break;
}
if ch.is_ascii_alphanumeric() {
out.push(ch.to_ascii_lowercase());
last_underscore = false;
} else if !last_underscore && !out.is_empty() {
out.push('_');
last_underscore = true;
}
}
let trimmed = out.trim_end_matches('_').to_string();
if trimmed.is_empty() {
fallback.to_string()
} else {
trimmed
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::hit_stats::{record_hits_to_data_dir, HitRecord};
use crate::store::{MemoryStore, PersistentStore, PersistentStoreConfig};
use crate::types::{ChunkType, MemoryChunk};
use tempfile::tempdir;
fn disabled_inputs() -> AutoScopeInputs {
AutoScopeInputs {
default_tenant: "ignored".to_string(),
enabled: false,
}
}
fn enabled_inputs(tenant: &str) -> AutoScopeInputs {
AutoScopeInputs {
default_tenant: tenant.to_string(),
enabled: true,
}
}
#[test]
fn native_hook_payload_keeps_only_allowlisted_context() {
let dir = tempdir().unwrap();
let payload = json!({
"session_id": "claude-session",
"thread_id": "claude-thread",
"agent_id": "worker-2",
"parent_agent_id": "lead-1",
"model": "claude-fable-5",
"cwd": dir.path(),
"prompt": "do not retain this prompt",
"transcript_path": "/private/native-transcript.jsonl",
"tool_input": {"secret": "do not retain this tool input"}
});
let context = parse_native_hook_context(
NativeHookHarness::Claude,
std::io::Cursor::new(serde_json::to_vec(&payload).unwrap()),
Path::new("/unused"),
)
.unwrap();
let serialized = serde_json::to_string(&context).unwrap();
assert_eq!(context.harness.as_deref(), Some("claude"));
assert_eq!(context.native_session_id.as_deref(), Some("claude-session"));
assert_eq!(context.native_thread_id.as_deref(), Some("claude-thread"));
assert_eq!(context.native_agent_id.as_deref(), Some("worker-2"));
assert_eq!(context.native_parent_id.as_deref(), Some("lead-1"));
assert_eq!(context.model.as_deref(), Some("claude-fable-5"));
assert_eq!(context.cwd.as_deref(), dir.path().to_str());
assert_eq!(
native_hook_project_dir(Path::new("."), &context),
dir.path()
);
assert_eq!(
native_hook_project_dir(Path::new("/explicit/project"), &context),
Path::new("/explicit/project")
);
assert!(!serialized.contains("prompt"));
assert!(!serialized.contains("transcript"));
assert!(!serialized.contains("tool_input"));
assert!(!serialized.contains("do not retain"));
}
#[test]
fn native_hook_payload_is_bounded() {
let payload = vec![b' '; MAX_NATIVE_HOOK_BYTES as usize + 1];
let error = parse_native_hook_context(
NativeHookHarness::Codex,
std::io::Cursor::new(payload),
Path::new("."),
)
.unwrap_err();
assert!(error.to_string().contains("exceeds 65536 bytes"));
}
#[tokio::test]
async fn missing_scope_with_auto_disabled_is_a_clean_noop() {
let store = MemoryStore::new();
let dir = tempdir().unwrap();
let result = run_session_start_inner(
&store,
SessionStartOptions {
project_dir: dir.path().to_path_buf(),
},
disabled_inputs(),
)
.await
.unwrap();
assert_eq!(result["skipped"], "auto_scope_disabled");
assert!(!dir.path().join(".memd/project_scope.json").exists());
}
#[tokio::test]
async fn memd_skip_marker_suppresses_auto_scope() {
let store = MemoryStore::new();
let dir = tempdir().unwrap();
std::fs::write(dir.path().join(".memd-skip"), "").unwrap();
let result = run_session_start_inner(
&store,
SessionStartOptions {
project_dir: dir.path().to_path_buf(),
},
enabled_inputs("alice"),
)
.await
.unwrap();
assert_eq!(result["skipped"], "memd_skip_present");
assert!(!dir.path().join(".memd/project_scope.json").exists());
}
#[tokio::test]
async fn memd_skip_marker_suppresses_initialized_repository() {
let store = MemoryStore::new();
let dir = tempdir().unwrap();
let memd_dir = dir.path().join(".memd");
std::fs::create_dir_all(&memd_dir).unwrap();
let existing = ProjectScopeConfig {
tenant_id: "preexisting".to_string(),
project_id: Some("keep_me".to_string()),
interface: "cli".to_string(),
cli_command: "memd".to_string(),
agent_context_output: ".memd/context.md".to_string(),
project_dir: dir.path().display().to_string(),
};
let scope_bytes = format!("{}\n", serde_json::to_string_pretty(&existing).unwrap());
std::fs::write(memd_dir.join("project_scope.json"), &scope_bytes).unwrap();
std::fs::write(dir.path().join("memory.md"), "keep existing memory\n").unwrap();
std::fs::write(dir.path().join(".memd-skip"), "").unwrap();
let result = run_session_start_inner(
&store,
SessionStartOptions {
project_dir: dir.path().to_path_buf(),
},
enabled_inputs("ignored"),
)
.await
.unwrap();
assert_eq!(result["skipped"], "memd_skip_present");
assert_eq!(
std::fs::read(memd_dir.join("project_scope.json")).unwrap(),
scope_bytes.as_bytes()
);
assert_eq!(
std::fs::read_to_string(dir.path().join("memory.md")).unwrap(),
"keep existing memory\n"
);
}
#[tokio::test]
async fn auto_scope_writes_minimal_project_scope_and_runs_session() {
let store = MemoryStore::new();
let dir = tempdir().unwrap();
let project_dir = dir.path().join("my-cool-repo");
std::fs::create_dir_all(&project_dir).unwrap();
let result = run_session_start_inner(
&store,
SessionStartOptions {
project_dir: project_dir.clone(),
},
enabled_inputs("alice"),
)
.await
.unwrap();
assert_eq!(result["auto_scoped"], true);
assert!(result.get("memory_md").is_some());
let scope: serde_json::Value = serde_json::from_str(
&std::fs::read_to_string(project_dir.join(".memd/project_scope.json")).unwrap(),
)
.unwrap();
assert_eq!(scope["tenant_id"], "alice");
assert_eq!(scope["project_id"], "my_cool_repo");
assert_eq!(scope["interface"], "cli");
assert!(!project_dir.join("AGENTS.md").exists());
assert!(!project_dir.join("CLAUDE.md").exists());
assert!(!project_dir.join(".memd/tenant_scope.json").exists());
assert!(!project_dir.join(".memd/memory_guardrails.md").exists());
assert!(project_dir.join("memory.md").exists());
}
#[tokio::test]
async fn existing_scope_is_left_alone() {
let store = MemoryStore::new();
let dir = tempdir().unwrap();
std::fs::create_dir_all(dir.path().join(".memd")).unwrap();
let existing = ProjectScopeConfig {
tenant_id: "preexisting".to_string(),
project_id: Some("keep_me".to_string()),
interface: "cli".to_string(),
cli_command: "memd".to_string(),
agent_context_output: ".memd/context.md".to_string(),
project_dir: dir.path().display().to_string(),
};
std::fs::write(
dir.path().join(".memd/project_scope.json"),
format!("{}\n", serde_json::to_string_pretty(&existing).unwrap()),
)
.unwrap();
let before = std::fs::read_to_string(dir.path().join(".memd/project_scope.json")).unwrap();
let result = run_session_start_inner(
&store,
SessionStartOptions {
project_dir: dir.path().to_path_buf(),
},
enabled_inputs("would_overwrite"),
)
.await
.unwrap();
assert_eq!(result["auto_scoped"], false);
let after = std::fs::read_to_string(dir.path().join(".memd/project_scope.json")).unwrap();
assert_eq!(
before, after,
"auto-scope must not overwrite existing scope"
);
}
#[test]
fn derive_project_id_handles_punctuation_and_edge_cases() {
assert_eq!(
derive_project_id(Path::new("/tmp/Foo-Bar.v2")),
"foo_bar_v2"
);
assert_eq!(derive_project_id(Path::new("/tmp/__weird__")), "weird");
assert_eq!(derive_project_id(Path::new("/")), "project");
assert_eq!(derive_project_id(Path::new(".")), "project");
assert_eq!(derive_project_id(Path::new("/tmp/café")), "caf");
}
fn linked_worktree_layout(root: &Path, relative_gitdir: bool) -> (PathBuf, PathBuf) {
let main = root.join("My-Repo");
let git_dir = main.join(".git");
let admin = git_dir.join("worktrees/cc-wt");
std::fs::create_dir_all(&admin).unwrap();
std::fs::write(admin.join("commondir"), "../..\n").unwrap();
let worktree = main.join(".claude/worktrees/cc-20261017-074438-555a");
std::fs::create_dir_all(&worktree).unwrap();
std::fs::write(
admin.join("gitdir"),
format!("{}/.git\n", worktree.display()),
)
.unwrap();
let target = if relative_gitdir {
"../../../.git/worktrees/cc-wt".to_string()
} else {
admin.display().to_string()
};
std::fs::write(worktree.join(".git"), format!("gitdir: {target}\n")).unwrap();
(main, worktree)
}
#[test]
fn derive_project_id_resolves_a_linked_worktree_to_its_main_checkout() {
for relative in [false, true] {
let tmp = tempdir().unwrap();
let (main, worktree) = linked_worktree_layout(tmp.path(), relative);
assert_eq!(derive_project_id(&main), "my_repo");
assert_eq!(
derive_project_id(&worktree),
"my_repo",
"relative={relative}"
);
}
}
#[test]
fn derive_project_id_keeps_the_basename_for_plain_repos_and_submodules() {
let tmp = tempdir().unwrap();
let plain = tmp.path().join("Plain-Repo");
std::fs::create_dir_all(plain.join(".git")).unwrap();
assert_eq!(derive_project_id(&plain), "plain_repo");
let non_git = tmp.path().join("scratch");
std::fs::create_dir_all(&non_git).unwrap();
assert_eq!(derive_project_id(&non_git), "scratch");
let super_repo = tmp.path().join("super");
let module_git = super_repo.join(".git/modules/sub");
std::fs::create_dir_all(&module_git).unwrap();
let submodule = super_repo.join("Sub-Module");
std::fs::create_dir_all(&submodule).unwrap();
std::fs::write(
submodule.join(".git"),
format!("gitdir: {}\n", module_git.display()),
)
.unwrap();
assert_eq!(derive_project_id(&submodule), "sub_module");
let broken = tmp.path().join("Broken-Tree");
std::fs::create_dir_all(&broken).unwrap();
std::fs::write(broken.join(".git"), "gitdir: /does/not/exist\n").unwrap();
assert_eq!(derive_project_id(&broken), "broken_tree");
}
#[test]
fn sanitize_id_caps_length_and_validates_against_tenant_rules() {
let huge = "a".repeat(500);
let out = sanitize_id(&huge, "fallback");
assert!(
out.len() <= MAX_AUTO_ID_LEN,
"len {} should be capped at {}",
out.len(),
MAX_AUTO_ID_LEN
);
assert!(TenantId::validate(&out).is_ok());
assert_eq!(sanitize_id("Felix-Schulz", "x"), "felix_schulz");
assert_eq!(sanitize_id(" ", "fallback"), "fallback");
}
#[test]
fn from_env_falls_back_to_user_then_default() {
let inputs = AutoScopeInputs::from_env();
assert!(!inputs.default_tenant.is_empty());
assert!(
TenantId::validate(&inputs.default_tenant).is_ok(),
"from_env produced an invalid tenant_id: {:?}",
inputs.default_tenant
);
}
#[tokio::test]
async fn invalid_existing_scope_is_preserved_with_diagnostic() {
let store = MemoryStore::new();
let dir = tempdir().unwrap();
let project_dir = dir.path().join("recover-me");
std::fs::create_dir_all(project_dir.join(".memd")).unwrap();
let scope_path = project_dir.join(".memd/project_scope.json");
let original = b"{not json";
std::fs::write(&scope_path, original).unwrap();
let result = run_session_start_inner(
&store,
SessionStartOptions {
project_dir: project_dir.clone(),
},
enabled_inputs("alice"),
)
.await
.unwrap();
assert_eq!(result["skipped"], "invalid_project_scope");
assert_eq!(result["project_scope"], scope_path.display().to_string());
assert!(result["diagnostic"]
.as_str()
.unwrap()
.contains("was preserved"));
assert_eq!(std::fs::read(&scope_path).unwrap(), original);
assert!(!project_dir.join("memory.md").exists());
}
#[tokio::test]
async fn invalid_legacy_scope_is_preserved_without_creating_project_scope() {
let store = MemoryStore::new();
let dir = tempdir().unwrap();
let project_dir = dir.path().join("legacy-repo");
std::fs::create_dir_all(project_dir.join(".memd")).unwrap();
let legacy_path = project_dir.join(".memd/config.json");
let project_scope_path = project_dir.join(".memd/project_scope.json");
let original = b"{not legacy json";
std::fs::write(&legacy_path, original).unwrap();
let result = run_session_start_inner(
&store,
SessionStartOptions {
project_dir: project_dir.clone(),
},
enabled_inputs("would_mask_routing"),
)
.await
.unwrap();
assert_eq!(result["skipped"], "invalid_project_scope");
assert_eq!(result["project_scope"], legacy_path.display().to_string());
assert!(result["diagnostic"]
.as_str()
.unwrap()
.contains("was preserved"));
assert_eq!(std::fs::read(legacy_path).unwrap(), original);
assert!(!project_scope_path.exists());
assert!(!project_dir.join("memory.md").exists());
}
#[tokio::test]
async fn legacy_config_without_scope_is_preserved_while_auto_scoping() {
let store = MemoryStore::new();
let dir = tempdir().unwrap();
let project_dir = dir.path().join("wiki-repo");
std::fs::create_dir_all(project_dir.join(".memd")).unwrap();
let legacy_path = project_dir.join(".memd/config.json");
let original = b"{\n \"wiki\": {\"outdir\": \"wiki\"}\n}\n";
std::fs::write(&legacy_path, original).unwrap();
let result = run_session_start_inner(
&store,
SessionStartOptions {
project_dir: project_dir.clone(),
},
enabled_inputs("alice"),
)
.await
.unwrap();
assert_eq!(result["auto_scoped"], true);
assert_eq!(std::fs::read(&legacy_path).unwrap(), original);
let scope: serde_json::Value = serde_json::from_str(
&std::fs::read_to_string(project_dir.join(".memd/project_scope.json")).unwrap(),
)
.unwrap();
assert_eq!(scope["tenant_id"], "alice");
assert_eq!(scope["project_id"], "wiki_repo");
assert!(project_dir.join("memory.md").exists());
}
#[tokio::test]
async fn valid_legacy_scope_is_preserved_as_fallback() {
let store = MemoryStore::new();
let dir = tempdir().unwrap();
let project_dir = dir.path().join("legacy-repo");
std::fs::create_dir_all(project_dir.join(".memd")).unwrap();
let legacy_path = project_dir.join(".memd/config.json");
let original = b"{\n \"tenant_id\": \"legacy_tenant\",\n \"project_id\": \"legacy_project\",\n \"wiki\": {\"outdir\": \"wiki\"}\n}\n";
std::fs::write(&legacy_path, original).unwrap();
let result = run_session_start_inner(
&store,
SessionStartOptions {
project_dir: project_dir.clone(),
},
enabled_inputs("would_replace_legacy"),
)
.await
.unwrap();
assert_eq!(result["auto_scoped"], false);
assert_eq!(result["memory_md"]["tenant_id"], "legacy_tenant");
assert_eq!(result["memory_md"]["project_id"], "legacy_project");
assert_eq!(std::fs::read(&legacy_path).unwrap(), original);
assert!(!project_dir.join(".memd/project_scope.json").exists());
assert!(project_dir.join("memory.md").exists());
}
#[tokio::test]
async fn legacy_project_without_tenant_remains_invalid() {
let store = MemoryStore::new();
let dir = tempdir().unwrap();
let project_dir = dir.path().join("legacy-repo");
std::fs::create_dir_all(project_dir.join(".memd")).unwrap();
let legacy_path = project_dir.join(".memd/config.json");
let original = b"{\"project_id\":\"must_not_be_replaced\"}\n";
std::fs::write(&legacy_path, original).unwrap();
let result = run_session_start_inner(
&store,
SessionStartOptions {
project_dir: project_dir.clone(),
},
enabled_inputs("would_mask_routing"),
)
.await
.unwrap();
assert_eq!(result["skipped"], "invalid_project_scope");
assert_eq!(result["project_scope"], legacy_path.display().to_string());
assert!(result["diagnostic"]
.as_str()
.unwrap()
.contains("missing tenant_id"));
assert_eq!(std::fs::read(&legacy_path).unwrap(), original);
assert!(!project_dir.join(".memd/project_scope.json").exists());
assert!(!project_dir.join("memory.md").exists());
}
#[test]
fn auto_scope_create_new_does_not_truncate_existing_file() {
let dir = tempdir().unwrap();
std::fs::create_dir_all(dir.path().join(".memd")).unwrap();
let scope_path = dir.path().join(".memd/project_scope.json");
let original = b"created by a concurrent startup\n";
std::fs::write(&scope_path, original).unwrap();
let outcome = maybe_auto_create_scope(dir.path(), &enabled_inputs("alice")).unwrap();
assert_eq!(outcome, AutoScopeOutcome::AlreadyExists);
assert_eq!(std::fs::read(scope_path).unwrap(), original);
}
#[tokio::test]
async fn session_start_uses_central_exposure_ledger() {
let data = tempdir().unwrap();
let project = tempdir().unwrap();
let mut config = PersistentStoreConfig {
data_dir: data.path().to_path_buf(),
enable_dense_search: false,
enable_hybrid_search: false,
enable_tiered_search: false,
backfill_hnsw_on_startup: false,
backfill_canonical_text_on_startup: false,
..Default::default()
};
let store = PersistentStore::open(config.clone()).unwrap();
let tenant = TenantId::new("central_tenant").unwrap();
let project_id = "central_project";
let chunk_id = store
.add(
MemoryChunk::new(
tenant.clone(),
"Validation: central-only exposure keeps an old startup fact active. \
Agent action: Verify session-start reads the store exposure ledger.",
ChunkType::Summary,
)
.with_project(ProjectId::from(project_id))
.with_tags(vec!["kind:evidence".to_string()]),
)
.await
.unwrap();
store
.metadata()
.force_timestamp_created(&chunk_id, 1)
.unwrap();
record_hits_to_data_dir(
data.path(),
&[HitRecord {
ts_ms: std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis() as i64,
chunk_id: chunk_id.to_string(),
tenant_id: tenant.to_string(),
project_id: Some(project_id.to_string()),
query_mode: "generic".to_string(),
rank: 1,
score: 1.0,
rendered: true,
}],
);
std::fs::create_dir_all(project.path().join(".memd")).unwrap();
let scope = ProjectScopeConfig {
tenant_id: tenant.to_string(),
project_id: Some(project_id.to_string()),
interface: "cli".to_string(),
cli_command: "memd".to_string(),
agent_context_output: ".memd/context.md".to_string(),
project_dir: project.path().display().to_string(),
};
std::fs::write(
project.path().join(".memd/project_scope.json"),
format!("{}\n", serde_json::to_string_pretty(&scope).unwrap()),
)
.unwrap();
drop(store);
config.read_only = true;
let store = PersistentStore::open(config).unwrap();
run_session_start_inner(
&store,
SessionStartOptions {
project_dir: project.path().to_path_buf(),
},
enabled_inputs("ignored"),
)
.await
.unwrap();
let rendered = std::fs::read_to_string(project.path().join("memory.md")).unwrap();
assert!(rendered.contains(&chunk_id.to_string()), "{rendered}");
assert!(
rendered.contains("priority: `14.0`"),
"central exposure should prevent the old-chunk penalty:\n{rendered}"
);
}
}