From 9b354242fbf64056a39b8dadb6de4a0153ecc7a0 Mon Sep 17 00:00:00 2001 From: Bradley Hilton Date: Tue, 3 Nov 2026 13:53:09 -0600 Subject: [PATCH 1/2] feat(vault): initialize the vault on first vault command Vault-facing commands now create the vault when it is absent, so a repository from `atomic init --no-vault` (or one that never ran `atomic vault init`) serves `atomic vault`, `atomic intent`, and `atomic memory` on first use instead of failing with "Vault not initialized". - Repository::ensure_vault: idempotent first-use initialization - CLI vault-ready openers for the local command bodies - VaultService handlers ensure before the domain call - Regression tests for the repository, CLI, and daemon path --- README.md | 5 + atomic-cli/src/commands/intent/attest.rs | 2 +- atomic-cli/src/commands/intent/delete.rs | 2 +- atomic-cli/src/commands/intent/link.rs | 2 +- atomic-cli/src/commands/intent/list.rs | 3 +- atomic-cli/src/commands/intent/new.rs | 2 +- atomic-cli/src/commands/intent/show.rs | 3 +- atomic-cli/src/commands/intent/update.rs | 5 +- atomic-cli/src/commands/intent/validate.rs | 2 +- atomic-cli/src/commands/intent/verify.rs | 2 +- atomic-cli/src/commands/memory/attest.rs | 2 +- atomic-cli/src/commands/memory/list.rs | 2 +- atomic-cli/src/commands/memory/new.rs | 2 +- atomic-cli/src/commands/memory/show.rs | 2 +- atomic-cli/src/commands/memory/validate.rs | 2 +- atomic-cli/src/commands/memory/verify.rs | 2 +- atomic-cli/src/commands/memory/write.rs | 2 +- atomic-cli/src/commands/mod.rs | 40 ++++++ atomic-cli/src/commands/vault/context.rs | 3 +- atomic-cli/src/commands/vault/goal.rs | 10 +- atomic-cli/src/commands/vault/list.rs | 2 +- atomic-cli/src/commands/vault/materialize.rs | 2 +- atomic-cli/src/commands/vault/show.rs | 3 +- atomic-cli/src/commands/vault/summaries.rs | 2 +- atomic-cli/src/commands/vault/sync.rs | 2 +- atomic-cli/tests/it/main.rs | 1 + atomic-cli/tests/it/vault_auto_init_test.rs | 124 +++++++++++++++++++ atomic-repository/src/repository/vault.rs | 36 ++++++ libatomic/src/daemon/services_agent.rs | 72 +++++++---- 29 files changed, 282 insertions(+), 57 deletions(-) create mode 100644 atomic-cli/tests/it/vault_auto_init_test.rs diff --git a/README.md b/README.md index 2f026a9a..556469db 100644 --- a/README.md +++ b/README.md @@ -252,6 +252,11 @@ Atomic's CRDT semantic layer (Trunk → Branch → Leaf) tracks changes at the t Every repository has a **vault** — a versioned knowledge store that persists what your team and your agents learn across sessions. Goals, decisions, architecture context, and working memory all live in `.vault/` as structured markdown with cryptographic provenance. +Any vault-facing command (`atomic vault …`, `atomic intent …`, `atomic memory …`) +creates the vault on first use if it does not exist yet. `atomic vault init` is +only needed when you want the defaults created and recorded up front, for +example after `atomic init --no-vault`. + ```bash # Initialize the vault in your repo atomic vault init diff --git a/atomic-cli/src/commands/intent/attest.rs b/atomic-cli/src/commands/intent/attest.rs index d80311cd..e25c4c02 100644 --- a/atomic-cli/src/commands/intent/attest.rs +++ b/atomic-cli/src/commands/intent/attest.rs @@ -52,7 +52,7 @@ impl Command for IntentAttest { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let inputs = bridge::read_intent(&repo, &self.id)?; diff --git a/atomic-cli/src/commands/intent/delete.rs b/atomic-cli/src/commands/intent/delete.rs index d07e4463..b98ed58d 100644 --- a/atomic-cli/src/commands/intent/delete.rs +++ b/atomic-cli/src/commands/intent/delete.rs @@ -42,7 +42,7 @@ impl Command for IntentDelete { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; if !self.force { // Check that the intent exists before prompting. diff --git a/atomic-cli/src/commands/intent/link.rs b/atomic-cli/src/commands/intent/link.rs index 009a9130..baaf17a1 100644 --- a/atomic-cli/src/commands/intent/link.rs +++ b/atomic-cli/src/commands/intent/link.rs @@ -35,7 +35,7 @@ impl Command for IntentLink { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; repo.vault_intent_link(&self.id, &self.goal) .map_err(CliError::Repository)?; diff --git a/atomic-cli/src/commands/intent/list.rs b/atomic-cli/src/commands/intent/list.rs index 492b24cf..b56f812a 100644 --- a/atomic-cli/src/commands/intent/list.rs +++ b/atomic-cli/src/commands/intent/list.rs @@ -488,8 +488,7 @@ impl Command for IntentList { } let root = find_repository_root()?; - let repo = - crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_readonly_repository_with_vault(&root)?; // Resolve the verifying identity ONCE (soft-fail to "no identity"). let verifier = resolve_verifier(&self.identity)?; diff --git a/atomic-cli/src/commands/intent/new.rs b/atomic-cli/src/commands/intent/new.rs index 2eccd534..16c4bacc 100644 --- a/atomic-cli/src/commands/intent/new.rs +++ b/atomic-cli/src/commands/intent/new.rs @@ -155,7 +155,7 @@ impl Command for IntentNew { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let (created, kind) = create_intent(&repo, &self.title, &self.kind, self.review.as_deref())?; diff --git a/atomic-cli/src/commands/intent/show.rs b/atomic-cli/src/commands/intent/show.rs index dda3568e..eb3835ca 100644 --- a/atomic-cli/src/commands/intent/show.rs +++ b/atomic-cli/src/commands/intent/show.rs @@ -71,8 +71,7 @@ impl Command for IntentShow { } let root = find_repository_root()?; - let repo = - crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_readonly_repository_with_vault(&root)?; let inputs = bridge::read_intent(&repo, &self.id)?; let attestation = bridge::load_attestation(&repo, &self.id, &inputs)?; diff --git a/atomic-cli/src/commands/intent/update.rs b/atomic-cli/src/commands/intent/update.rs index 34cc4c18..1f409ba3 100644 --- a/atomic-cli/src/commands/intent/update.rs +++ b/atomic-cli/src/commands/intent/update.rs @@ -96,8 +96,7 @@ impl IntentUpdate { }; let root = find_repository_root()?; let uid = { - let repo = - crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_readonly_repository_with_vault(&root)?; let inputs = super::bridge::read_intent(&repo, &self.id).map_err(CliError::Repository)?; inputs @@ -153,7 +152,7 @@ impl Command for IntentUpdate { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let content = self.resolve_body()?; if self.status.is_none() diff --git a/atomic-cli/src/commands/intent/validate.rs b/atomic-cli/src/commands/intent/validate.rs index 78e223f3..cc0ea60c 100644 --- a/atomic-cli/src/commands/intent/validate.rs +++ b/atomic-cli/src/commands/intent/validate.rs @@ -56,7 +56,7 @@ impl Command for IntentValidate { })? } else { let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let inputs = bridge::read_intent(&repo, &self.id_or_path)?; match bridge::load_attestation(&repo, &self.id_or_path, &inputs)? { bridge::Attestation::Fresh(node) => *node, diff --git a/atomic-cli/src/commands/intent/verify.rs b/atomic-cli/src/commands/intent/verify.rs index 5be735da..9b55562f 100644 --- a/atomic-cli/src/commands/intent/verify.rs +++ b/atomic-cli/src/commands/intent/verify.rs @@ -81,7 +81,7 @@ impl Command for IntentVerify { impl IntentVerify { async fn execute(&self) -> CliResult<()> { let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let inputs = bridge::read_intent(&repo, &self.id)?; let node = match bridge::load_attestation(&repo, &self.id, &inputs)? { diff --git a/atomic-cli/src/commands/memory/attest.rs b/atomic-cli/src/commands/memory/attest.rs index 3e51bb9e..6cac0e4f 100644 --- a/atomic-cli/src/commands/memory/attest.rs +++ b/atomic-cli/src/commands/memory/attest.rs @@ -38,7 +38,7 @@ impl Command for MemoryAttest { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let inputs = bridge::read_memory(&repo, &self.id)?; diff --git a/atomic-cli/src/commands/memory/list.rs b/atomic-cli/src/commands/memory/list.rs index 102b8feb..6aa0d04a 100644 --- a/atomic-cli/src/commands/memory/list.rs +++ b/atomic-cli/src/commands/memory/list.rs @@ -422,7 +422,7 @@ impl Command for MemoryList { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let verifier = resolve_verifier(&self.identity)?; diff --git a/atomic-cli/src/commands/memory/new.rs b/atomic-cli/src/commands/memory/new.rs index 1639baec..9f23c726 100644 --- a/atomic-cli/src/commands/memory/new.rs +++ b/atomic-cli/src/commands/memory/new.rs @@ -111,7 +111,7 @@ impl Command for MemoryNew { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let id = self.id.clone().unwrap_or_else(generate_ulid_lowercased); let vault_path = bridge::normalize_memory_path(&id); diff --git a/atomic-cli/src/commands/memory/show.rs b/atomic-cli/src/commands/memory/show.rs index 4f2c92d2..499cd82b 100644 --- a/atomic-cli/src/commands/memory/show.rs +++ b/atomic-cli/src/commands/memory/show.rs @@ -85,7 +85,7 @@ impl Command for MemoryShow { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let inputs = bridge::read_memory(&repo, &self.id)?; let attestation = bridge::load_attestation(&repo, &self.id, &inputs)?; diff --git a/atomic-cli/src/commands/memory/validate.rs b/atomic-cli/src/commands/memory/validate.rs index 59ad658b..b4dd1476 100644 --- a/atomic-cli/src/commands/memory/validate.rs +++ b/atomic-cli/src/commands/memory/validate.rs @@ -55,7 +55,7 @@ impl Command for MemoryValidate { })? } else { let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let inputs = bridge::read_memory(&repo, &self.id_or_path)?; match bridge::load_attestation(&repo, &self.id_or_path, &inputs)? { bridge::Attestation::Fresh(node) => *node, diff --git a/atomic-cli/src/commands/memory/verify.rs b/atomic-cli/src/commands/memory/verify.rs index a0e9f01c..1d6023aa 100644 --- a/atomic-cli/src/commands/memory/verify.rs +++ b/atomic-cli/src/commands/memory/verify.rs @@ -34,7 +34,7 @@ impl Command for MemoryVerify { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let inputs = bridge::read_memory(&repo, &self.id)?; let node = match bridge::load_attestation(&repo, &self.id, &inputs)? { diff --git a/atomic-cli/src/commands/memory/write.rs b/atomic-cli/src/commands/memory/write.rs index be0576d8..fae7bc35 100644 --- a/atomic-cli/src/commands/memory/write.rs +++ b/atomic-cli/src/commands/memory/write.rs @@ -45,7 +45,7 @@ impl Command for MemoryWrite { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; // Freeform body from stdin — no lift/gate; this is the raw path. use std::io::Read; diff --git a/atomic-cli/src/commands/mod.rs b/atomic-cli/src/commands/mod.rs index 5d76c4cc..a446ad33 100644 --- a/atomic-cli/src/commands/mod.rs +++ b/atomic-cli/src/commands/mod.rs @@ -417,6 +417,46 @@ pub(crate) fn open_readonly_repository( Repository::open_readonly_wait(path, std::time::Duration::from_secs(10)) } +/// Open the repository at `root` with a vault guaranteed to exist. +/// +/// Vault-facing commands — the `vault`, `intent`, and `memory` families — +/// open through this helper so a repository created without a vault +/// (`atomic init --no-vault`, or one that never ran `atomic vault init`) +/// serves them on first use instead of failing with +/// "Vault not initialized". +/// +/// The initialization is [`Repository::ensure_vault`], the same idempotent +/// path `atomic vault init` uses. It runs at most once: an existing vault is +/// never re-initialized. +pub fn open_repository_with_vault(root: &Path) -> CliResult { + let repo = Repository::open(root).map_err(CliError::from)?; + ensure_vault_exists(&repo)?; + Ok(repo) +} + +/// Read-only variant of [`open_repository_with_vault`]. +/// +/// An already-initialized repository keeps the migration-free read-only +/// handle. Only the absent-vault case pays the writable open needed to create +/// and record the vault tables. +pub(crate) fn open_readonly_repository_with_vault(root: &Path) -> CliResult { + let repo = open_readonly_repository(root).map_err(CliError::from)?; + if repo.has_vault().map_err(CliError::from)? { + return Ok(repo); + } + drop(repo); + open_repository_with_vault(root) +} + +/// One-time implicit vault initialization, announced on stderr so `--json` +/// output stays parseable. +fn ensure_vault_exists(repo: &Repository) -> CliResult<()> { + if repo.ensure_vault().map_err(CliError::from)? { + eprintln!("Initialized vault at {}", repo.vault_dir().display()); + } + Ok(()) +} + /// Open a repository or return a user-friendly error. /// /// This is a convenience wrapper around [`open_repository`] that provides diff --git a/atomic-cli/src/commands/vault/context.rs b/atomic-cli/src/commands/vault/context.rs index 7e755d56..1f5d0b3f 100644 --- a/atomic-cli/src/commands/vault/context.rs +++ b/atomic-cli/src/commands/vault/context.rs @@ -196,8 +196,7 @@ impl Command for Context { } let root = find_repository_root()?; - let repo = - crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_readonly_repository_with_vault(&root)?; let limit = self.limit; let candidates = self.gather_candidates(&repo, limit)?; diff --git a/atomic-cli/src/commands/vault/goal.rs b/atomic-cli/src/commands/vault/goal.rs index c1ca4cbc..265a6376 100644 --- a/atomic-cli/src/commands/vault/goal.rs +++ b/atomic-cli/src/commands/vault/goal.rs @@ -180,7 +180,7 @@ impl Command for GoalStart { return Ok(()); } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let result = repo .vault_goal_start(GoalStartOptions { @@ -230,7 +230,7 @@ impl Command for GoalStop { return Ok(()); } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; // Find the goal to stop let goal_name = match &self.goal { @@ -291,7 +291,7 @@ impl Command for GoalResume { return Ok(()); } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let info = repo .vault_goal_resume(&self.goal) @@ -387,7 +387,7 @@ impl Command for GoalList { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let filter = if self.status == "all" { Some("all") @@ -434,7 +434,7 @@ impl Command for GoalShow { return Ok(()); } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let entry = repo .vault_goal_show(&self.goal) diff --git a/atomic-cli/src/commands/vault/list.rs b/atomic-cli/src/commands/vault/list.rs index 9ffabd3d..07d29c7b 100644 --- a/atomic-cli/src/commands/vault/list.rs +++ b/atomic-cli/src/commands/vault/list.rs @@ -121,7 +121,7 @@ impl Command for List { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let type_filter = self.r#type.as_deref().and_then(VaultEntryType::parse); let prefix = self.prefix.as_deref().unwrap_or(""); diff --git a/atomic-cli/src/commands/vault/materialize.rs b/atomic-cli/src/commands/vault/materialize.rs index c9540675..0be2a808 100644 --- a/atomic-cli/src/commands/vault/materialize.rs +++ b/atomic-cli/src/commands/vault/materialize.rs @@ -55,7 +55,7 @@ impl Command for Materialize { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; if let Some(ref path) = self.path { repo.vault_materialize(path).map_err(CliError::Repository)?; diff --git a/atomic-cli/src/commands/vault/show.rs b/atomic-cli/src/commands/vault/show.rs index e26e4e2a..db3c1190 100644 --- a/atomic-cli/src/commands/vault/show.rs +++ b/atomic-cli/src/commands/vault/show.rs @@ -56,8 +56,7 @@ impl Command for Show { } let root = find_repository_root()?; - let repo = - crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_readonly_repository_with_vault(&root)?; let entry = repo .vault_retrieve(&self.path) diff --git a/atomic-cli/src/commands/vault/summaries.rs b/atomic-cli/src/commands/vault/summaries.rs index 805454bd..af8fecd8 100644 --- a/atomic-cli/src/commands/vault/summaries.rs +++ b/atomic-cli/src/commands/vault/summaries.rs @@ -67,7 +67,7 @@ impl Command for Summaries { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let prefix = match &self.goal { Some(name) => format!("goals/{}/", name), diff --git a/atomic-cli/src/commands/vault/sync.rs b/atomic-cli/src/commands/vault/sync.rs index 6b87a94d..00525ed3 100644 --- a/atomic-cli/src/commands/vault/sync.rs +++ b/atomic-cli/src/commands/vault/sync.rs @@ -43,7 +43,7 @@ impl Command for Sync { } let root = find_repository_root()?; - let repo = Repository::open(&root).map_err(CliError::Repository)?; + let repo = crate::commands::open_repository_with_vault(&root)?; let updated = repo .vault_record_working_copy() diff --git a/atomic-cli/tests/it/main.rs b/atomic-cli/tests/it/main.rs index d98588ff..28e6aae3 100644 --- a/atomic-cli/tests/it/main.rs +++ b/atomic-cli/tests/it/main.rs @@ -81,6 +81,7 @@ mod session_integration_test; mod shim_census_cb13a_test; mod status_git_cb11a_test; mod unrecord_integration_test; +mod vault_auto_init_test; mod vault_context_integration_test; mod view_confirmation_integration_test; mod working_copy_preservation_test; diff --git a/atomic-cli/tests/it/vault_auto_init_test.rs b/atomic-cli/tests/it/vault_auto_init_test.rs new file mode 100644 index 00000000..8e52ec35 --- /dev/null +++ b/atomic-cli/tests/it/vault_auto_init_test.rs @@ -0,0 +1,124 @@ +//! Vault-facing commands initialize the vault on first use. +//! +//! `atomic init --no-vault` is the repository that deliberately carries no +//! vault. The vault families (`atomic vault`, `atomic intent`, `atomic memory`) +//! must create it themselves instead of failing with +//! "Vault not initialized. Run `atomic vault init` first." +#![cfg(not(windows))] + +use std::path::Path; +use std::process::{Command, Output}; + +use tempfile::TempDir; + +const ATOMIC_BIN: &str = env!("CARGO_BIN_EXE_atomic"); + +fn atomic(repo_dir: &Path, home_dir: &Path, args: &[&str]) -> Output { + Command::new(ATOMIC_BIN) + .args(args) + .current_dir(repo_dir) + .env("HOME", home_dir) + .env_remove("ATOMIC_SERVICE") + .env_remove("ATOMIC_RPC") + .output() + .expect("run atomic") +} + +fn success(output: Output) -> String { + assert!( + output.status.success(), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + String::from_utf8(output.stdout).unwrap() +} + +/// A repository created without a vault — the state every vault command must +/// recover from. +fn vaultless_repo() -> (TempDir, TempDir) { + let repo = TempDir::new().unwrap(); + let home = TempDir::new().unwrap(); + let init = atomic(repo.path(), home.path(), &["init", "--no-vault"]); + assert!( + init.status.success(), + "init --no-vault failed: {}", + String::from_utf8_lossy(&init.stderr) + ); + assert!(!repo.path().join(".vault").exists()); + (repo, home) +} + +fn intents_written(repo: &Path) -> bool { + std::fs::read_dir(repo.join(".vault/intents")) + .map(|mut entries| { + entries.any(|entry| { + entry + .map(|e| e.path().join("intent.md").is_file()) + .unwrap_or(false) + }) + }) + .unwrap_or(false) +} + +#[test] +fn intent_new_initializes_the_vault_and_the_next_command_does_not() { + let (repo, home) = vaultless_repo(); + + let created = success(atomic( + repo.path(), + home.path(), + &["intent", "new", "First intent"], + )); + assert!(created.contains("Created intent"), "{created}"); + assert!(repo.path().join(".vault/intents").exists()); + assert!( + intents_written(repo.path()), + "the intent's markdown entry must exist in .vault/intents" + ); + + // Reading the vault afterwards works and never re-initializes it: an + // explicit init reports the vault as already present. + let listed = success(atomic(repo.path(), home.path(), &["intent", "list"])); + assert!(listed.contains("backlog"), "{listed}"); + let init = success(atomic(repo.path(), home.path(), &["vault", "init"])); + assert!(init.contains("already initialized"), "{init}"); +} + +#[test] +fn vault_goal_and_materialize_initialize_before_running() { + let (repo, home) = vaultless_repo(); + + let started = success(atomic( + repo.path(), + home.path(), + &["vault", "goal", "start"], + )); + assert!(started.contains("Started goal"), "{started}"); + + let materialized = success(atomic(repo.path(), home.path(), &["vault", "materialize"])); + assert!(materialized.contains("Materialized"), "{materialized}"); + + assert!(repo.path().join(".vault/goals").exists()); +} + +#[test] +fn memory_new_initializes_the_vault_and_persists_the_memory() { + let (repo, home) = vaultless_repo(); + + let created = success(atomic( + repo.path(), + home.path(), + &[ + "memory", + "new", + "--kind", + "lesson", + "--text", + "Boring designs outlive clever ones.", + ], + )); + assert!(created.contains("Created memory"), "{created}"); + + let listed = success(atomic(repo.path(), home.path(), &["memory", "list"])); + assert!(listed.contains("lesson"), "{listed}"); +} diff --git a/atomic-repository/src/repository/vault.rs b/atomic-repository/src/repository/vault.rs index 73180722..f1a70f31 100644 --- a/atomic-repository/src/repository/vault.rs +++ b/atomic-repository/src/repository/vault.rs @@ -25,6 +25,27 @@ impl Repository { .map_err(|e| RepositoryError::Database(e.to_string())) } + /// Ensure the vault exists, initializing it on first use. + /// + /// Vault-facing entry points call this so a repository created without a + /// vault (`atomic init --no-vault`) still serves `atomic vault`, + /// `atomic intent`, and `atomic memory` without a manual + /// `atomic vault init`. + /// + /// Initialization is the same idempotent path as + /// [`init_vault`](Self::init_vault): an existing `.vault/` working copy is + /// hydrated from disk and default content is installed only where nothing + /// exists yet. + /// + /// Returns `true` when this call created the vault. + pub fn ensure_vault(&self) -> Result { + if self.has_vault()? { + return Ok(false); + } + self.init_vault()?; + Ok(true) + } + /// Initialize the vault in this repository. /// /// Creates the vault tables in the pristine database and the @@ -1607,6 +1628,21 @@ mod tests { assert!(repo.vault_dir().join("scratch").exists()); } + #[test] + fn test_ensure_vault_initializes_once() { + let dir = tempdir().unwrap(); + let repo = Repository::init(dir.path()).unwrap(); + assert!(!repo.has_vault().unwrap()); + + assert!(repo.ensure_vault().unwrap()); + assert!(repo.has_vault().unwrap()); + assert!(repo.vault_dir().join("memory").exists()); + + // Second call is the no-op path: an initialized vault is never reset. + assert!(!repo.ensure_vault().unwrap()); + assert!(repo.has_vault().unwrap()); + } + #[test] fn test_init_vault_idempotent() { let dir = tempdir().unwrap(); diff --git a/libatomic/src/daemon/services_agent.rs b/libatomic/src/daemon/services_agent.rs index d22d8a3f..931b06ba 100644 --- a/libatomic/src/daemon/services_agent.rs +++ b/libatomic/src/daemon/services_agent.rs @@ -33,7 +33,7 @@ use tonic::{Request, Response, Status}; use super::convert::*; use super::journal_sink::DirectJournalSink; -use super::state::{domain_status, repository_error, DaemonState}; +use super::state::{domain_status, repository_error, DaemonState, RepoHandle}; // --------------------------------------------------------------------------- // VaultService @@ -1196,6 +1196,30 @@ pub(crate) fn response_meta(meta: &Option) -> Option }) } +/// Open the request's repository with its vault guaranteed to exist. +/// +/// The local command bodies initialize the vault on first use; a routed +/// request reaches the same domain methods through this handler, so it +/// applies the same guarantee before the domain call. An existing vault is +/// never re-initialized. +fn vault_repository(handle: &RepoHandle) -> Result { + let repo = handle.repository()?; + repo.ensure_vault().map_err(repository_error)?; + Ok(repo) +} + +/// Read path of [`vault_repository`]: keeps the read-concurrency handle when +/// the vault already exists, and only takes the writable open to create it on +/// first use. +fn vault_repository_readonly(handle: &RepoHandle) -> Result { + let repo = handle.repository_readonly()?; + if repo.has_vault().map_err(repository_error)? { + return Ok(repo); + } + drop(repo); + vault_repository(handle) +} + #[tonic::async_trait] impl vault_service_server::VaultService for VaultImpl { async fn create_vault_entity( @@ -1232,7 +1256,7 @@ impl vault_service_server::VaultService for VaultImpl { let result = tokio::task::spawn_blocking({ let handle = handle_for_task; move || { - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; let created = repo .vault_intent_create(IntentCreateOptions { title: title.clone(), @@ -1305,7 +1329,7 @@ impl vault_service_server::VaultService for VaultImpl { let result = tokio::task::spawn_blocking({ let handle = handle_for_task; move || { - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; repo.vault_goal_start(atomic_repository::GoalStartOptions { name: (!title.is_empty()).then_some(title.clone()), developer, @@ -1362,7 +1386,7 @@ impl vault_service_server::VaultService for VaultImpl { let id = id.clone(); let body = body_for_store; move || { - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; let mut frontmatter = Map::new(); frontmatter.insert("uid".into(), Value::String(id)); frontmatter.insert("memoryKind".into(), Value::String(memory_kind)); @@ -1449,7 +1473,7 @@ impl vault_service_server::VaultService for VaultImpl { let id = request.id.clone(); let response = tokio::task::spawn_blocking(move || match kind { Kind::Intent => { - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; let mut options = IntentUpdateOptions::default(); match update { UpdateKind::Status(status) => { @@ -1516,7 +1540,7 @@ impl vault_service_server::VaultService for VaultImpl { } Kind::Memory => match update { UpdateKind::Body(body) => { - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; let vault_path = format!("memory/{id}.md"); let entry = repo .vault_retrieve(&vault_path) @@ -1560,7 +1584,7 @@ impl vault_service_server::VaultService for VaultImpl { // `atomic memory write` — the raw store + materialize // (create-or-replace at the named vault path), with the // content hash riding the response. - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; let hash = repo .vault_store( &memory_write.path, @@ -1592,7 +1616,7 @@ impl vault_service_server::VaultService for VaultImpl { // `vault goal stop` — the goal to stop (empty = the most // recent active goal) + the promote/discard options. UpdateKind::GoalStop(goal_stop) => { - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; let goal_name = match &goal_stop.goal { Some(name) => name.clone(), None => repo @@ -1640,7 +1664,7 @@ impl vault_service_server::VaultService for VaultImpl { } // `vault goal resume`. UpdateKind::GoalResume(goal_resume) => { - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; let info = repo .vault_goal_resume(&goal_resume.goal) .map_err(repository_error)?; @@ -1710,7 +1734,7 @@ impl vault_service_server::VaultService for VaultImpl { // attestation: the vault-show projection never consults one). if let Some(path) = path.as_deref().filter(|path| !path.is_empty()) { // A query: read-only open with the read-concurrency wait. - let repo = handle.repository_readonly()?; + let repo = vault_repository_readonly(&handle)?; let entry = repo .vault_retrieve(path) .map_err(repository_error)? @@ -1746,7 +1770,7 @@ impl vault_service_server::VaultService for VaultImpl { match kind { Kind::Intent => { // A query: read-only open with the read-concurrency wait. - let repo = handle.repository_readonly()?; + let repo = vault_repository_readonly(&handle)?; let entry = repo.vault_intent_show(&id).map_err(repository_error)?; let frontmatter = parse_frontmatter(&entry)?; let title = frontmatter @@ -1782,7 +1806,7 @@ impl vault_service_server::VaultService for VaultImpl { } Kind::Memory => { // A query: read-only open with the read-concurrency wait. - let repo = handle.repository_readonly()?; + let repo = vault_repository_readonly(&handle)?; // The memory id/path resolver (no manifest lookup, no // case-folding): a bare id, a `memory/` path, an // `.md` name, or a full `memory/.md` path all @@ -1818,7 +1842,7 @@ impl vault_service_server::VaultService for VaultImpl { Kind::Goal => { // `atomic vault goal show ` — the stored goal.md // entry (content + frontmatter ride the bundle). - let repo = handle.repository_readonly()?; + let repo = vault_repository_readonly(&handle)?; let entry = repo.vault_goal_show(&id).map_err(repository_error)?; let bundle = include_bundle .then(|| vault_entry_bundle(&repo, Some(Kind::Goal), &id, &entry)) @@ -1907,7 +1931,7 @@ impl vault_service_server::VaultService for VaultImpl { // `atomic vault summaries` — the ToolResult entries under the // prefix, each with its filename-stem id and a 200-char content // preview (the local body's exact enumeration + preview). - let repo = handle.repository_readonly()?; + let repo = vault_repository_readonly(&handle)?; let entries = repo .vault_list(&path_prefix, Some(VaultEntryType::ToolResult)) .map_err(repository_error)?; @@ -1943,7 +1967,7 @@ impl vault_service_server::VaultService for VaultImpl { match kind { Some(Kind::Intent) => { // A query: read-only open with the read-concurrency wait. - let repo = handle.repository_readonly()?; + let repo = vault_repository_readonly(&handle)?; // The verifying identity resolved ONCE (soft-fail to "no // identity"; a named-but-missing identity is a hard error). let verifier = resolve_listing_verifier(&identity)?; @@ -2015,7 +2039,7 @@ impl vault_service_server::VaultService for VaultImpl { } Some(Kind::Memory) => { // A query: read-only open with the read-concurrency wait. - let repo = handle.repository_readonly()?; + let repo = vault_repository_readonly(&handle)?; // The verifying identity resolved ONCE — the `verifies` // column's resolver (the same soft/hard-fail rule). let verifier = resolve_listing_verifier(&identity)?; @@ -2159,7 +2183,7 @@ impl vault_service_server::VaultService for VaultImpl { } Some(Kind::Goal) => { // A query: read-only open with the read-concurrency wait. - let repo = handle.repository_readonly()?; + let repo = vault_repository_readonly(&handle)?; let goals = repo .vault_goal_list(status_filter.as_deref()) .map_err(repository_error)?; @@ -2198,7 +2222,7 @@ impl vault_service_server::VaultService for VaultImpl { } None => { // A query: read-only open with the read-concurrency wait. - let repo = handle.repository_readonly()?; + let repo = vault_repository_readonly(&handle)?; // `vault list`: EVERY vault entry with its type, content // size, and updated-at date, filtered by the path prefix // and the parsed entry type — the same enumeration the @@ -2270,7 +2294,7 @@ impl vault_service_server::VaultService for VaultImpl { })?; let response = tokio::task::spawn_blocking(move || { // A query: read-only open with the read-concurrency wait. - let repo = handle.repository_readonly()?; + let repo = vault_repository_readonly(&handle)?; let id = match subject { validate_vault_entity_request::Subject::Id(id) => id, validate_vault_entity_request::Subject::Document(_) => { @@ -2379,7 +2403,7 @@ impl vault_service_server::VaultService for VaultImpl { let response = tokio::task::spawn_blocking({ let handle = handle_for_task; move || { - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; let synced = repo.vault_record_working_copy().map_err(repository_error)?; Ok::<_, Status>(SyncVaultResponse { entities_synced: synced.len() as u32, @@ -2471,7 +2495,7 @@ impl vault_service_server::VaultService for VaultImpl { let _gate = gate_handle.exclusive().await; let (entries, context) = tokio::task::spawn_blocking(move || { // A query: read-only open with the read-concurrency wait. - let repo = handle_for_task.repository_readonly()?; + let repo = vault_repository_readonly(&handle_for_task)?; let mut entries = Vec::new(); let want = |kind: Kind| kinds.is_empty() || kinds.contains(&(kind as i32)); if want(Kind::Intent) { @@ -2555,7 +2579,7 @@ impl vault_service_server::VaultService for VaultImpl { let meta = request.meta.clone(); let path = request.path.clone().filter(|path| !path.is_empty()); let (count, materialized_path) = tokio::task::spawn_blocking(move || { - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; match path { Some(path) => { repo.vault_materialize(&path).map_err(repository_error)?; @@ -2594,7 +2618,7 @@ impl vault_service_server::VaultService for VaultImpl { // domain's (vault_intent_delete); the normalized id + removed // file ride the response so the client prints the local report. Kind::Intent => { - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; let result = repo.vault_intent_delete(&id).map_err(repository_error)?; Ok::<_, Status>((result.id, result.intent_file)) } @@ -2641,7 +2665,7 @@ impl vault_service_server::VaultService for VaultImpl { let intent_id = source.id.clone(); let goal_name = target.id.clone(); tokio::task::spawn_blocking(move || { - let repo = handle.repository()?; + let repo = vault_repository(&handle)?; repo.vault_intent_link(&intent_id, &goal_name) .map_err(repository_error)?; Ok::<_, Status>(()) From 0aaa43230cf939438ec79f2c1d7c15c279be1745 Mon Sep 17 00:00:00 2001 From: Bradley Hilton Date: Tue, 3 Nov 2026 14:32:27 -0600 Subject: [PATCH 2/2] fix(vault): keep vault reads read-only Read commands (vault show/list/context/summaries, goal list/show, intent show/list/validate/verify, memory show/list/validate/verify) open read-only and never initialize the vault. A read-only checkout now keeps working, and a read never creates `.vault/`. Vault writes still initialize on first use: vault goal start/stop/ resume, materialize, sync, intent new/update/delete/link/attest, and memory new/write/attest. The daemon's VaultService applies the same split: write handlers ensure the vault; read handlers do not. Tests: reads leave `.vault/` absent, and a read-only database still serves `vault list`. --- README.md | 5 +-- atomic-cli/src/commands/intent/list.rs | 3 +- atomic-cli/src/commands/intent/show.rs | 3 +- atomic-cli/src/commands/intent/update.rs | 3 +- atomic-cli/src/commands/intent/validate.rs | 3 +- atomic-cli/src/commands/intent/verify.rs | 3 +- atomic-cli/src/commands/memory/list.rs | 3 +- atomic-cli/src/commands/memory/show.rs | 3 +- atomic-cli/src/commands/memory/validate.rs | 3 +- atomic-cli/src/commands/memory/verify.rs | 3 +- atomic-cli/src/commands/mod.rs | 30 ++++++--------- atomic-cli/src/commands/vault/context.rs | 3 +- atomic-cli/src/commands/vault/goal.rs | 6 ++- atomic-cli/src/commands/vault/list.rs | 3 +- atomic-cli/src/commands/vault/show.rs | 3 +- atomic-cli/src/commands/vault/summaries.rs | 3 +- atomic-cli/tests/it/vault_auto_init_test.rs | 42 +++++++++++++++++++++ atomic-repository/src/repository/vault.rs | 9 +++-- libatomic/src/daemon/services_agent.rs | 42 ++++++++------------- 19 files changed, 104 insertions(+), 69 deletions(-) diff --git a/README.md b/README.md index 556469db..26c4a1c0 100644 --- a/README.md +++ b/README.md @@ -252,10 +252,7 @@ Atomic's CRDT semantic layer (Trunk → Branch → Leaf) tracks changes at the t Every repository has a **vault** — a versioned knowledge store that persists what your team and your agents learn across sessions. Goals, decisions, architecture context, and working memory all live in `.vault/` as structured markdown with cryptographic provenance. -Any vault-facing command (`atomic vault …`, `atomic intent …`, `atomic memory …`) -creates the vault on first use if it does not exist yet. `atomic vault init` is -only needed when you want the defaults created and recorded up front, for -example after `atomic init --no-vault`. +Vault **writes** — `atomic vault goal start/stop/resume`, `atomic vault materialize`, `atomic vault sync`, `atomic intent new/update/delete/link/attest`, and `atomic memory new/write/attest` — create the vault on first use if it does not exist yet. Reads never mutate the checkout: on a repository without a vault they return empty/not-found, so read-only checkouts keep working. `atomic vault init` is only needed when you want the defaults created and recorded up front, for example after `atomic init --no-vault`. ```bash # Initialize the vault in your repo diff --git a/atomic-cli/src/commands/intent/list.rs b/atomic-cli/src/commands/intent/list.rs index b56f812a..492b24cf 100644 --- a/atomic-cli/src/commands/intent/list.rs +++ b/atomic-cli/src/commands/intent/list.rs @@ -488,7 +488,8 @@ impl Command for IntentList { } let root = find_repository_root()?; - let repo = crate::commands::open_readonly_repository_with_vault(&root)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; // Resolve the verifying identity ONCE (soft-fail to "no identity"). let verifier = resolve_verifier(&self.identity)?; diff --git a/atomic-cli/src/commands/intent/show.rs b/atomic-cli/src/commands/intent/show.rs index eb3835ca..dda3568e 100644 --- a/atomic-cli/src/commands/intent/show.rs +++ b/atomic-cli/src/commands/intent/show.rs @@ -71,7 +71,8 @@ impl Command for IntentShow { } let root = find_repository_root()?; - let repo = crate::commands::open_readonly_repository_with_vault(&root)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let inputs = bridge::read_intent(&repo, &self.id)?; let attestation = bridge::load_attestation(&repo, &self.id, &inputs)?; diff --git a/atomic-cli/src/commands/intent/update.rs b/atomic-cli/src/commands/intent/update.rs index 1f409ba3..702d67dc 100644 --- a/atomic-cli/src/commands/intent/update.rs +++ b/atomic-cli/src/commands/intent/update.rs @@ -96,7 +96,8 @@ impl IntentUpdate { }; let root = find_repository_root()?; let uid = { - let repo = crate::commands::open_readonly_repository_with_vault(&root)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let inputs = super::bridge::read_intent(&repo, &self.id).map_err(CliError::Repository)?; inputs diff --git a/atomic-cli/src/commands/intent/validate.rs b/atomic-cli/src/commands/intent/validate.rs index cc0ea60c..0cb27418 100644 --- a/atomic-cli/src/commands/intent/validate.rs +++ b/atomic-cli/src/commands/intent/validate.rs @@ -56,7 +56,8 @@ impl Command for IntentValidate { })? } else { let root = find_repository_root()?; - let repo = crate::commands::open_repository_with_vault(&root)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let inputs = bridge::read_intent(&repo, &self.id_or_path)?; match bridge::load_attestation(&repo, &self.id_or_path, &inputs)? { bridge::Attestation::Fresh(node) => *node, diff --git a/atomic-cli/src/commands/intent/verify.rs b/atomic-cli/src/commands/intent/verify.rs index 9b55562f..eea408b9 100644 --- a/atomic-cli/src/commands/intent/verify.rs +++ b/atomic-cli/src/commands/intent/verify.rs @@ -81,7 +81,8 @@ impl Command for IntentVerify { impl IntentVerify { async fn execute(&self) -> CliResult<()> { let root = find_repository_root()?; - let repo = crate::commands::open_repository_with_vault(&root)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let inputs = bridge::read_intent(&repo, &self.id)?; let node = match bridge::load_attestation(&repo, &self.id, &inputs)? { diff --git a/atomic-cli/src/commands/memory/list.rs b/atomic-cli/src/commands/memory/list.rs index 6aa0d04a..60cd15ad 100644 --- a/atomic-cli/src/commands/memory/list.rs +++ b/atomic-cli/src/commands/memory/list.rs @@ -422,7 +422,8 @@ impl Command for MemoryList { } let root = find_repository_root()?; - let repo = crate::commands::open_repository_with_vault(&root)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let verifier = resolve_verifier(&self.identity)?; diff --git a/atomic-cli/src/commands/memory/show.rs b/atomic-cli/src/commands/memory/show.rs index 499cd82b..b320794d 100644 --- a/atomic-cli/src/commands/memory/show.rs +++ b/atomic-cli/src/commands/memory/show.rs @@ -85,7 +85,8 @@ impl Command for MemoryShow { } let root = find_repository_root()?; - let repo = crate::commands::open_repository_with_vault(&root)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let inputs = bridge::read_memory(&repo, &self.id)?; let attestation = bridge::load_attestation(&repo, &self.id, &inputs)?; diff --git a/atomic-cli/src/commands/memory/validate.rs b/atomic-cli/src/commands/memory/validate.rs index b4dd1476..fe761848 100644 --- a/atomic-cli/src/commands/memory/validate.rs +++ b/atomic-cli/src/commands/memory/validate.rs @@ -55,7 +55,8 @@ impl Command for MemoryValidate { })? } else { let root = find_repository_root()?; - let repo = crate::commands::open_repository_with_vault(&root)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let inputs = bridge::read_memory(&repo, &self.id_or_path)?; match bridge::load_attestation(&repo, &self.id_or_path, &inputs)? { bridge::Attestation::Fresh(node) => *node, diff --git a/atomic-cli/src/commands/memory/verify.rs b/atomic-cli/src/commands/memory/verify.rs index 1d6023aa..4f80300c 100644 --- a/atomic-cli/src/commands/memory/verify.rs +++ b/atomic-cli/src/commands/memory/verify.rs @@ -34,7 +34,8 @@ impl Command for MemoryVerify { } let root = find_repository_root()?; - let repo = crate::commands::open_repository_with_vault(&root)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let inputs = bridge::read_memory(&repo, &self.id)?; let node = match bridge::load_attestation(&repo, &self.id, &inputs)? { diff --git a/atomic-cli/src/commands/mod.rs b/atomic-cli/src/commands/mod.rs index a446ad33..a36f4bac 100644 --- a/atomic-cli/src/commands/mod.rs +++ b/atomic-cli/src/commands/mod.rs @@ -417,13 +417,19 @@ pub(crate) fn open_readonly_repository( Repository::open_readonly_wait(path, std::time::Duration::from_secs(10)) } -/// Open the repository at `root` with a vault guaranteed to exist. +/// Open the repository at `root` for a command that writes to the vault, +/// creating the vault when it does not exist yet. /// -/// Vault-facing commands — the `vault`, `intent`, and `memory` families — -/// open through this helper so a repository created without a vault +/// Vault *writes* — `goal start/stop/resume`, `materialize`, `sync`, +/// `intent new/update/delete/link/attest`, `memory new/write/attest` — open +/// through this helper so a repository created without a vault /// (`atomic init --no-vault`, or one that never ran `atomic vault init`) -/// serves them on first use instead of failing with -/// "Vault not initialized". +/// works on first use instead of failing with "Vault not initialized". +/// +/// Read-only commands deliberately do NOT use this helper: they open with +/// [`open_readonly_repository`], so a read never mutates a checkout — an +/// uninitialized vault reads as empty/not-found, and the first write +/// initializes it. /// /// The initialization is [`Repository::ensure_vault`], the same idempotent /// path `atomic vault init` uses. It runs at most once: an existing vault is @@ -434,20 +440,6 @@ pub fn open_repository_with_vault(root: &Path) -> CliResult { Ok(repo) } -/// Read-only variant of [`open_repository_with_vault`]. -/// -/// An already-initialized repository keeps the migration-free read-only -/// handle. Only the absent-vault case pays the writable open needed to create -/// and record the vault tables. -pub(crate) fn open_readonly_repository_with_vault(root: &Path) -> CliResult { - let repo = open_readonly_repository(root).map_err(CliError::from)?; - if repo.has_vault().map_err(CliError::from)? { - return Ok(repo); - } - drop(repo); - open_repository_with_vault(root) -} - /// One-time implicit vault initialization, announced on stderr so `--json` /// output stays parseable. fn ensure_vault_exists(repo: &Repository) -> CliResult<()> { diff --git a/atomic-cli/src/commands/vault/context.rs b/atomic-cli/src/commands/vault/context.rs index 1f5d0b3f..7e755d56 100644 --- a/atomic-cli/src/commands/vault/context.rs +++ b/atomic-cli/src/commands/vault/context.rs @@ -196,7 +196,8 @@ impl Command for Context { } let root = find_repository_root()?; - let repo = crate::commands::open_readonly_repository_with_vault(&root)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let limit = self.limit; let candidates = self.gather_candidates(&repo, limit)?; diff --git a/atomic-cli/src/commands/vault/goal.rs b/atomic-cli/src/commands/vault/goal.rs index 265a6376..15dc1afc 100644 --- a/atomic-cli/src/commands/vault/goal.rs +++ b/atomic-cli/src/commands/vault/goal.rs @@ -387,7 +387,8 @@ impl Command for GoalList { } let root = find_repository_root()?; - let repo = crate::commands::open_repository_with_vault(&root)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let filter = if self.status == "all" { Some("all") @@ -434,7 +435,8 @@ impl Command for GoalShow { return Ok(()); } let root = find_repository_root()?; - let repo = crate::commands::open_repository_with_vault(&root)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let entry = repo .vault_goal_show(&self.goal) diff --git a/atomic-cli/src/commands/vault/list.rs b/atomic-cli/src/commands/vault/list.rs index 07d29c7b..5fbcbfa3 100644 --- a/atomic-cli/src/commands/vault/list.rs +++ b/atomic-cli/src/commands/vault/list.rs @@ -121,7 +121,8 @@ impl Command for List { } let root = find_repository_root()?; - let repo = crate::commands::open_repository_with_vault(&root)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let type_filter = self.r#type.as_deref().and_then(VaultEntryType::parse); let prefix = self.prefix.as_deref().unwrap_or(""); diff --git a/atomic-cli/src/commands/vault/show.rs b/atomic-cli/src/commands/vault/show.rs index db3c1190..e26e4e2a 100644 --- a/atomic-cli/src/commands/vault/show.rs +++ b/atomic-cli/src/commands/vault/show.rs @@ -56,7 +56,8 @@ impl Command for Show { } let root = find_repository_root()?; - let repo = crate::commands::open_readonly_repository_with_vault(&root)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let entry = repo .vault_retrieve(&self.path) diff --git a/atomic-cli/src/commands/vault/summaries.rs b/atomic-cli/src/commands/vault/summaries.rs index af8fecd8..8dfd1372 100644 --- a/atomic-cli/src/commands/vault/summaries.rs +++ b/atomic-cli/src/commands/vault/summaries.rs @@ -67,7 +67,8 @@ impl Command for Summaries { } let root = find_repository_root()?; - let repo = crate::commands::open_repository_with_vault(&root)?; + let repo = + crate::commands::open_readonly_repository(&root).map_err(CliError::Repository)?; let prefix = match &self.goal { Some(name) => format!("goals/{}/", name), diff --git a/atomic-cli/tests/it/vault_auto_init_test.rs b/atomic-cli/tests/it/vault_auto_init_test.rs index 8e52ec35..3c72f64e 100644 --- a/atomic-cli/tests/it/vault_auto_init_test.rs +++ b/atomic-cli/tests/it/vault_auto_init_test.rs @@ -48,6 +48,15 @@ fn vaultless_repo() -> (TempDir, TempDir) { (repo, home) } +/// Permit reads, deny database writes — the read-only checkout state a +/// CI mount or a `chmod`ed tree presents. +fn make_database_read_only(repo: &Path) { + let db = repo.join(".atomic/atomic.redb"); + let mut permissions = std::fs::metadata(&db).unwrap().permissions(); + permissions.set_readonly(true); + std::fs::set_permissions(&db, permissions).unwrap(); +} + fn intents_written(repo: &Path) -> bool { std::fs::read_dir(repo.join(".vault/intents")) .map(|mut entries| { @@ -101,6 +110,39 @@ fn vault_goal_and_materialize_initialize_before_running() { assert!(repo.path().join(".vault/goals").exists()); } +#[test] +fn reads_do_not_initialize_the_vault() { + let (repo, home) = vaultless_repo(); + + let listed = success(atomic(repo.path(), home.path(), &["vault", "list"])); + assert!(listed.contains("No vault entries found"), "{listed}"); + let intents = success(atomic(repo.path(), home.path(), &["intent", "list"])); + assert!(intents.contains("No intents found"), "{intents}"); + let memories = success(atomic(repo.path(), home.path(), &["memory", "list"])); + assert!(memories.contains("No memories found"), "{memories}"); + + assert!( + !repo.path().join(".vault").exists(), + "a read must never create the vault" + ); +} + +#[test] +fn read_only_checkout_serves_vault_reads() { + let (repo, home) = vaultless_repo(); + make_database_read_only(repo.path()); + + let listed = success(atomic(repo.path(), home.path(), &["vault", "list"])); + assert!(listed.contains("No vault entries found"), "{listed}"); + assert!(!repo.path().join(".vault").exists()); + + let mut permissions = std::fs::metadata(repo.path().join(".atomic/atomic.redb")) + .unwrap() + .permissions(); + permissions.set_readonly(false); + std::fs::set_permissions(repo.path().join(".atomic/atomic.redb"), permissions).unwrap(); +} + #[test] fn memory_new_initializes_the_vault_and_persists_the_memory() { let (repo, home) = vaultless_repo(); diff --git a/atomic-repository/src/repository/vault.rs b/atomic-repository/src/repository/vault.rs index f1a70f31..f952e147 100644 --- a/atomic-repository/src/repository/vault.rs +++ b/atomic-repository/src/repository/vault.rs @@ -27,10 +27,11 @@ impl Repository { /// Ensure the vault exists, initializing it on first use. /// - /// Vault-facing entry points call this so a repository created without a - /// vault (`atomic init --no-vault`) still serves `atomic vault`, - /// `atomic intent`, and `atomic memory` without a manual - /// `atomic vault init`. + /// Vault *write* paths call this so a repository created without a vault + /// (`atomic init --no-vault`) still supports vault and intent/memory + /// writes without a manual `atomic vault init`. Read paths never call it: + /// reads must not mutate a checkout, so an uninitialized vault reads as + /// empty/not-found. /// /// Initialization is the same idempotent path as /// [`init_vault`](Self::init_vault): an existing `.vault/` working copy is diff --git a/libatomic/src/daemon/services_agent.rs b/libatomic/src/daemon/services_agent.rs index 931b06ba..9e23300a 100644 --- a/libatomic/src/daemon/services_agent.rs +++ b/libatomic/src/daemon/services_agent.rs @@ -1198,28 +1198,16 @@ pub(crate) fn response_meta(meta: &Option) -> Option /// Open the request's repository with its vault guaranteed to exist. /// -/// The local command bodies initialize the vault on first use; a routed -/// request reaches the same domain methods through this handler, so it -/// applies the same guarantee before the domain call. An existing vault is -/// never re-initialized. +/// Vault-write handlers use this; read handlers open +/// `repository_readonly` directly, so a routed read never initializes the +/// vault or touches a read-only checkout. An existing vault is never +/// re-initialized. fn vault_repository(handle: &RepoHandle) -> Result { let repo = handle.repository()?; repo.ensure_vault().map_err(repository_error)?; Ok(repo) } -/// Read path of [`vault_repository`]: keeps the read-concurrency handle when -/// the vault already exists, and only takes the writable open to create it on -/// first use. -fn vault_repository_readonly(handle: &RepoHandle) -> Result { - let repo = handle.repository_readonly()?; - if repo.has_vault().map_err(repository_error)? { - return Ok(repo); - } - drop(repo); - vault_repository(handle) -} - #[tonic::async_trait] impl vault_service_server::VaultService for VaultImpl { async fn create_vault_entity( @@ -1734,7 +1722,7 @@ impl vault_service_server::VaultService for VaultImpl { // attestation: the vault-show projection never consults one). if let Some(path) = path.as_deref().filter(|path| !path.is_empty()) { // A query: read-only open with the read-concurrency wait. - let repo = vault_repository_readonly(&handle)?; + let repo = handle.repository_readonly()?; let entry = repo .vault_retrieve(path) .map_err(repository_error)? @@ -1770,7 +1758,7 @@ impl vault_service_server::VaultService for VaultImpl { match kind { Kind::Intent => { // A query: read-only open with the read-concurrency wait. - let repo = vault_repository_readonly(&handle)?; + let repo = handle.repository_readonly()?; let entry = repo.vault_intent_show(&id).map_err(repository_error)?; let frontmatter = parse_frontmatter(&entry)?; let title = frontmatter @@ -1806,7 +1794,7 @@ impl vault_service_server::VaultService for VaultImpl { } Kind::Memory => { // A query: read-only open with the read-concurrency wait. - let repo = vault_repository_readonly(&handle)?; + let repo = handle.repository_readonly()?; // The memory id/path resolver (no manifest lookup, no // case-folding): a bare id, a `memory/` path, an // `.md` name, or a full `memory/.md` path all @@ -1842,7 +1830,7 @@ impl vault_service_server::VaultService for VaultImpl { Kind::Goal => { // `atomic vault goal show ` — the stored goal.md // entry (content + frontmatter ride the bundle). - let repo = vault_repository_readonly(&handle)?; + let repo = handle.repository_readonly()?; let entry = repo.vault_goal_show(&id).map_err(repository_error)?; let bundle = include_bundle .then(|| vault_entry_bundle(&repo, Some(Kind::Goal), &id, &entry)) @@ -1931,7 +1919,7 @@ impl vault_service_server::VaultService for VaultImpl { // `atomic vault summaries` — the ToolResult entries under the // prefix, each with its filename-stem id and a 200-char content // preview (the local body's exact enumeration + preview). - let repo = vault_repository_readonly(&handle)?; + let repo = handle.repository_readonly()?; let entries = repo .vault_list(&path_prefix, Some(VaultEntryType::ToolResult)) .map_err(repository_error)?; @@ -1967,7 +1955,7 @@ impl vault_service_server::VaultService for VaultImpl { match kind { Some(Kind::Intent) => { // A query: read-only open with the read-concurrency wait. - let repo = vault_repository_readonly(&handle)?; + let repo = handle.repository_readonly()?; // The verifying identity resolved ONCE (soft-fail to "no // identity"; a named-but-missing identity is a hard error). let verifier = resolve_listing_verifier(&identity)?; @@ -2039,7 +2027,7 @@ impl vault_service_server::VaultService for VaultImpl { } Some(Kind::Memory) => { // A query: read-only open with the read-concurrency wait. - let repo = vault_repository_readonly(&handle)?; + let repo = handle.repository_readonly()?; // The verifying identity resolved ONCE — the `verifies` // column's resolver (the same soft/hard-fail rule). let verifier = resolve_listing_verifier(&identity)?; @@ -2183,7 +2171,7 @@ impl vault_service_server::VaultService for VaultImpl { } Some(Kind::Goal) => { // A query: read-only open with the read-concurrency wait. - let repo = vault_repository_readonly(&handle)?; + let repo = handle.repository_readonly()?; let goals = repo .vault_goal_list(status_filter.as_deref()) .map_err(repository_error)?; @@ -2222,7 +2210,7 @@ impl vault_service_server::VaultService for VaultImpl { } None => { // A query: read-only open with the read-concurrency wait. - let repo = vault_repository_readonly(&handle)?; + let repo = handle.repository_readonly()?; // `vault list`: EVERY vault entry with its type, content // size, and updated-at date, filtered by the path prefix // and the parsed entry type — the same enumeration the @@ -2294,7 +2282,7 @@ impl vault_service_server::VaultService for VaultImpl { })?; let response = tokio::task::spawn_blocking(move || { // A query: read-only open with the read-concurrency wait. - let repo = vault_repository_readonly(&handle)?; + let repo = handle.repository_readonly()?; let id = match subject { validate_vault_entity_request::Subject::Id(id) => id, validate_vault_entity_request::Subject::Document(_) => { @@ -2495,7 +2483,7 @@ impl vault_service_server::VaultService for VaultImpl { let _gate = gate_handle.exclusive().await; let (entries, context) = tokio::task::spawn_blocking(move || { // A query: read-only open with the read-concurrency wait. - let repo = vault_repository_readonly(&handle_for_task)?; + let repo = handle_for_task.repository_readonly()?; let mut entries = Vec::new(); let want = |kind: Kind| kinds.is_empty() || kinds.contains(&(kind as i32)); if want(Kind::Intent) {