fix: remove fallback — three layers are canonical, no backward compat

- paths.rs: getters return direct paths (no if-exists-fallback)
  config_json → .flow-config/config.json (always)
  frecency → ~/.flow/projects/{slug}/frecency.json (always)
  memory_dir → ~/.flow/projects/{slug}/memory/ (always)
- init.rs: migration uses MOVE (rename), not copy
  Old files removed after migration, not left behind
- guard.rs: uses load_resolved() only, no .flow/ fallback
- Tests: 3 fallback tests replaced with direct-path tests

381 tests pass.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: z23cc

bin/flowctl

@@ -352,9 +352,7 @@ pub fn cmd_guard(json_mode: bool, layer: String) {
     };
 
     // ── Priority chain: project-context → stack config → auto-detection ──
-    // Try three-layer resolution first (.flow-config/ then .flow/), fall back to direct load.
-    let pc = ProjectContext::load_resolved()
-        .or_else(|| ProjectContext::load(&flow_dir));
+    let pc = ProjectContext::load_resolved();
     let pc_commands = pc.as_ref().map(|ctx| {
         let gc = &ctx.guard_commands;
         let mut cmds: Vec<(String, String, String)> = Vec::new();

flowctl/crates/flowctl-cli/src/commands/admin/guard.rs

@@ -111,32 +111,32 @@ pub fn cmd_init(json: bool) {
         }
     }
 
-    // ── Migrate existing files to new locations (copy, not move) ───────
+    // ── Migrate existing files to new locations (MOVE, not copy) ────────
 
     // config.json → .flow-config/config.json
     let old_config = flow_dir.join("config.json");
     let new_config = config_dir.join("config.json");
     if old_config.exists() && !new_config.exists() {
-        if fs::copy(&old_config, &new_config).is_ok() {
-            actions.push("migrated config.json → .flow-config/".to_string());
+        if fs::rename(&old_config, &new_config).is_ok() {
+            actions.push("moved config.json → .flow-config/".to_string());
         }
     }
 
     // project-context.md → .flow-config/project-context.md
     let old_pc = flow_dir.join("project-context.md");
     let new_pc = config_dir.join("project-context.md");
     if old_pc.exists() && !new_pc.exists() {
-        if fs::copy(&old_pc, &new_pc).is_ok() {
-            actions.push("migrated project-context.md → .flow-config/".to_string());
+        if fs::rename(&old_pc, &new_pc).is_ok() {
+            actions.push("moved project-context.md → .flow-config/".to_string());
         }
     }
 
     // invariants.md → .flow-config/invariants.md
     let old_inv = flow_dir.join("invariants.md");
     let new_inv = config_dir.join("invariants.md");
     if old_inv.exists() && !new_inv.exists() {
-        if fs::copy(&old_inv, &new_inv).is_ok() {
-            actions.push("migrated invariants.md → .flow-config/".to_string());
+        if fs::rename(&old_inv, &new_inv).is_ok() {
+            actions.push("moved invariants.md → .flow-config/".to_string());
         }
     }
 
@@ -145,9 +145,13 @@ pub fn cmd_init(json: bool) {
         let old_frec = flow_dir.join("frecency.json");
         let new_frec = paths.global_project_dir.join("frecency.json");
         if old_frec.exists() && !new_frec.exists() {
-            if fs::copy(&old_frec, &new_frec).is_ok() {
-                actions.push("migrated frecency.json → global".to_string());
+            // rename may fail across filesystems, fall back to copy+delete
+            if fs::rename(&old_frec, &new_frec).is_err() {
+                if fs::copy(&old_frec, &new_frec).is_ok() {
+                    fs::remove_file(&old_frec).ok();
+                }
             }
+            actions.push("moved frecency.json → global".to_string());
         }
 
         let old_mem = flow_dir.join("memory");
@@ -158,24 +162,24 @@ pub fn cmd_init(json: bool) {
                     let dest = new_mem.join(entry.file_name());
                     fs::copy(entry.path(), &dest).ok();
                 }
-                actions.push("migrated memory/ → global".to_string());
+                fs::remove_dir_all(&old_mem).ok();
+                actions.push("moved memory/ → global".to_string());
             }
         }
     }
 
     // Create project-context.md with auto-detected stack info if missing
     // Write to .flow-config/ (primary location) instead of .flow/
     let project_context_path = config_dir.join("project-context.md");
-    let fallback_context_path = flow_dir.join("project-context.md");
-    if !project_context_path.exists() && !fallback_context_path.exists() {
+    if !project_context_path.exists() {
         let content = generate_project_context(&cwd);
         if let Err(e) = fs::write(&project_context_path, content) {
             eprintln!("warning: failed to create project-context.md: {e}");
         } else {
             actions.push("created project-context.md (auto-detected stack)".to_string());
         }
     }
-    let has_project_context = project_context_path.exists() || fallback_context_path.exists();
+    let has_project_context = project_context_path.exists();
 
     // Build output
     let message = if actions.is_empty() {

flowctl/crates/flowctl-cli/src/commands/admin/init.rs

@@ -54,49 +54,29 @@ impl FlowPaths {
 
     // -- Convenience path getters ----------------------------------------
 
-    /// config.json: .flow-config/config.json (primary) -> .flow/config.json (fallback).
+    /// config.json lives in .flow-config/
     pub fn config_json(&self) -> PathBuf {
-        let primary = self.config_dir.join("config.json");
-        if primary.exists() {
-            return primary;
-        }
-        self.runtime_dir.join("config.json") // backward compat
+        self.config_dir.join("config.json")
     }
 
-    /// project-context.md: .flow-config/ (primary) -> .flow/ (fallback).
+    /// project-context.md lives in .flow-config/
     pub fn project_context(&self) -> PathBuf {
-        let primary = self.config_dir.join("project-context.md");
-        if primary.exists() {
-            return primary;
-        }
-        self.runtime_dir.join("project-context.md")
+        self.config_dir.join("project-context.md")
     }
 
-    /// invariants.md: .flow-config/ (primary) -> .flow/ (fallback).
+    /// invariants.md lives in .flow-config/
     pub fn invariants(&self) -> PathBuf {
-        let primary = self.config_dir.join("invariants.md");
-        if primary.exists() {
-            return primary;
-        }
-        self.runtime_dir.join("invariants.md")
+        self.config_dir.join("invariants.md")
     }
 
-    /// frecency.json: ~/.flow/projects/{slug}/ (primary) -> .flow/ (fallback).
+    /// frecency.json lives in ~/.flow/projects/{slug}/
     pub fn frecency(&self) -> PathBuf {
-        let primary = self.global_project_dir.join("frecency.json");
-        if primary.exists() {
-            return primary;
-        }
-        self.runtime_dir.join("frecency.json")
+        self.global_project_dir.join("frecency.json")
     }
 
-    /// memory directory: ~/.flow/projects/{slug}/memory/ (primary) -> .flow/memory/ (fallback).
+    /// memory directory lives in ~/.flow/projects/{slug}/memory/
     pub fn memory_dir(&self) -> PathBuf {
-        let primary = self.global_project_dir.join("memory");
-        if primary.exists() {
-            return primary;
-        }
-        self.runtime_dir.join("memory")
+        self.global_project_dir.join("memory")
     }
 }
 
@@ -269,44 +249,37 @@ mod tests {
     }
 
     #[test]
-    fn config_json_fallback_when_no_primary() {
+    fn config_json_always_in_config_dir() {
         let tmp = tempfile::tempdir().unwrap();
-        let runtime = tmp.path().join(".flow");
         let config = tmp.path().join(".flow-config");
-        std::fs::create_dir_all(&runtime).unwrap();
-        // Do NOT create .flow-config/config.json
+        std::fs::create_dir_all(&config).unwrap();
 
         let paths = FlowPaths {
-            runtime_dir: runtime.clone(),
-            config_dir: config,
+            runtime_dir: tmp.path().join(".flow"),
+            config_dir: config.clone(),
             global_project_dir: tmp.path().join("global"),
             project_root: tmp.path().to_path_buf(),
             slug: "test".to_string(),
         };
 
-        assert_eq!(paths.config_json(), runtime.join("config.json"));
+        assert_eq!(paths.config_json(), config.join("config.json"));
     }
 
     #[test]
-    fn project_context_fallback() {
+    fn project_context_always_in_config_dir() {
         let tmp = tempfile::tempdir().unwrap();
-        let runtime = tmp.path().join(".flow");
         let config = tmp.path().join(".flow-config");
-        std::fs::create_dir_all(&runtime).unwrap();
+        std::fs::create_dir_all(&config).unwrap();
 
         let paths = FlowPaths {
-            runtime_dir: runtime.clone(),
-            config_dir: config,
+            runtime_dir: tmp.path().join(".flow"),
+            config_dir: config.clone(),
             global_project_dir: tmp.path().join("global"),
             project_root: tmp.path().to_path_buf(),
             slug: "test".to_string(),
         };
 
-        // No .flow-config/project-context.md -> falls back to .flow/
-        assert_eq!(
-            paths.project_context(),
-            runtime.join("project-context.md")
-        );
+        assert_eq!(paths.project_context(), config.join("project-context.md"));
     }
 
     #[test]
@@ -329,20 +302,19 @@ mod tests {
     }
 
     #[test]
-    fn frecency_fallback() {
+    fn frecency_always_in_global_dir() {
         let tmp = tempfile::tempdir().unwrap();
-        let runtime = tmp.path().join(".flow");
-        std::fs::create_dir_all(&runtime).unwrap();
+        let global = tmp.path().join("global");
 
         let paths = FlowPaths {
-            runtime_dir: runtime.clone(),
+            runtime_dir: tmp.path().join(".flow"),
             config_dir: tmp.path().join(".flow-config"),
-            global_project_dir: tmp.path().join("nonexistent-global"),
+            global_project_dir: global.clone(),
             project_root: tmp.path().to_path_buf(),
             slug: "test".to_string(),
         };
 
-        assert_eq!(paths.frecency(), runtime.join("frecency.json"));
+        assert_eq!(paths.frecency(), global.join("frecency.json"));
     }
 
     #[test]