feat(cli): migrate dep.rs and query.rs to json_store

dep.rs: rewrite add/rm commands to read/write task JSON directly.
query.rs: replace helpers (get_epic, get_task, get_all_tasks, etc.)
with json_store calls. Keep require_db bridge only for FileLock ops.

Remaining DB calls: gap.rs (1), stats.rs (3) — deferred to task .11.

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

Author: z23cc

flowctl/crates/flowctl-cli/src/commands/dep.rs

@@ -1,6 +1,4 @@
-//! Dependency commands: dep add, dep rm.
-//!
-//! DB canonical — all dependency operations go through the DB (sole source of truth).
+//! Dependency management commands: add, remove.
 
 use chrono::Utc;
 use clap::Subcommand;
@@ -38,20 +36,6 @@ fn ensure_flow_exists() -> std::path::PathBuf {
     flow_dir
 }
 
-/// Open DB connection (hard error if unavailable).
-fn require_db() -> crate::commands::db_shim::Connection {
-    crate::commands::db_shim::require_db()
-        .unwrap_or_else(|e| error_exit(&format!("DB required: {e}")))
-}
-
-/// Read a task from DB (sole source of truth).
-fn read_task(task_id: &str) -> flowctl_core::types::Task {
-    let conn = require_db();
-    let repo = crate::commands::db_shim::TaskRepo::new(&conn);
-    repo.get(task_id)
-        .unwrap_or_else(|_| error_exit(&format!("Task not found: {}", task_id)))
-}
-
 pub fn dispatch(cmd: &DepCmd, json: bool) {
     match cmd {
         DepCmd::Add { task, depends_on } => cmd_dep_add(json, task, depends_on),
@@ -60,7 +44,7 @@ pub fn dispatch(cmd: &DepCmd, json: bool) {
 }
 
 fn cmd_dep_add(json: bool, task_id: &str, depends_on: &str) {
-    ensure_flow_exists();
+    let flow_dir = ensure_flow_exists();
 
     if !is_task_id(task_id) {
         error_exit(&format!(
@@ -87,20 +71,15 @@ fn cmd_dep_add(json: bool, task_id: &str, depends_on: &str) {
         ));
     }
 
-    let mut task = read_task(task_id);
+    let mut task = flowctl_core::json_store::task_read(&flow_dir, task_id)
+        .unwrap_or_else(|_| error_exit(&format!("Task not found: {}", task_id)));
 
     if !task.depends_on.contains(&depends_on.to_string()) {
         task.depends_on.push(depends_on.to_string());
         task.updated_at = Utc::now();
-
-        // Write to DB
-        let conn = require_db();
-        let dep_repo = crate::commands::db_shim::DepRepo::new(&conn);
-        if let Err(e) = dep_repo.add_task_dep(task_id, depends_on) {
-            error_exit(&format!("Failed to add dep: {e}"));
+        if let Err(e) = flowctl_core::json_store::task_write_definition(&flow_dir, &task) {
+            error_exit(&format!("Failed to write task: {e}"));
         }
-        let task_repo = crate::commands::db_shim::TaskRepo::new(&conn);
-        let _ = task_repo.upsert(&task);
     }
 
     if json {
@@ -115,7 +94,7 @@ fn cmd_dep_add(json: bool, task_id: &str, depends_on: &str) {
 }
 
 fn cmd_dep_rm(json: bool, task_id: &str, depends_on: &str) {
-    ensure_flow_exists();
+    let flow_dir = ensure_flow_exists();
 
     if !is_task_id(task_id) {
         error_exit(&format!("Invalid task ID: {}", task_id));
@@ -124,20 +103,15 @@ fn cmd_dep_rm(json: bool, task_id: &str, depends_on: &str) {
         error_exit(&format!("Invalid dependency ID: {}", depends_on));
     }
 
-    let mut task = read_task(task_id);
+    let mut task = flowctl_core::json_store::task_read(&flow_dir, task_id)
+        .unwrap_or_else(|_| error_exit(&format!("Task not found: {}", task_id)));
 
     if let Some(pos) = task.depends_on.iter().position(|d| d == depends_on) {
         task.depends_on.remove(pos);
         task.updated_at = Utc::now();
-
-        // Write to DB
-        let conn = require_db();
-        let dep_repo = crate::commands::db_shim::DepRepo::new(&conn);
-        if let Err(e) = dep_repo.remove_task_dep(task_id, depends_on) {
-            error_exit(&format!("Failed to remove dep: {e}"));
+        if let Err(e) = flowctl_core::json_store::task_write_definition(&flow_dir, &task) {
+            error_exit(&format!("Failed to write task: {e}"));
         }
-        let task_repo = crate::commands::db_shim::TaskRepo::new(&conn);
-        let _ = task_repo.upsert(&task);
 
         if json {
             json_output(json!({
@@ -154,9 +128,9 @@ fn cmd_dep_rm(json: bool, task_id: &str, depends_on: &str) {
             "task": task_id,
             "depends_on": task.depends_on,
             "removed": false,
-            "message": format!("{} not in dependencies", depends_on),
+            "message": format!("{} was not in {}'s dependencies", depends_on, task_id),
         }));
     } else {
-        println!("{} is not a dependency of {}", depends_on, task_id);
+        println!("{} was not in {}'s dependencies", depends_on, task_id);
     }
 }

flowctl/crates/flowctl-cli/src/commands/query.rs

@@ -53,14 +53,13 @@ fn epic_to_json(epic: &Epic) -> serde_json::Value {
 fn task_to_json(task: &Task) -> serde_json::Value {
     let spec_path = format!(".flow/tasks/{}.md", task.id);
 
-    // Try to get runtime state from DB
+    // Try to get runtime state from JSON files
     let mut assignee: serde_json::Value = json!(null);
     let mut claimed_at: serde_json::Value = json!(null);
     let claim_note: serde_json::Value = json!("");
 
-    let conn = require_db();
-    let runtime_repo = crate::commands::db_shim::RuntimeRepo::new(&conn);
-    if let Ok(Some(state)) = runtime_repo.get(&task.id) {
+    let flow_dir = crate::commands::helpers::get_flow_dir();
+    if let Ok(state) = flowctl_core::json_store::state_read(&flow_dir, &task.id) {
         if let Some(a) = &state.assignee {
             assignee = json!(a);
         }
@@ -114,54 +113,55 @@ fn task_list_json(task: &Task) -> serde_json::Value {
     })
 }
 
-// ── DB-only data access ────────────────────────────────────────────
+// ── DB bridge for file locks (stays in DB) ─────────────────────────
 
-/// Open DB or exit with error (DB is sole source of truth).
 fn require_db() -> crate::commands::db_shim::Connection {
     crate::commands::db_shim::require_db()
         .unwrap_or_else(|e| error_exit(&format!("Cannot open database: {}", e)))
 }
 
-/// Get a single epic by ID from DB.
-fn get_epic(_flow_dir: &PathBuf, id: &str) -> Option<Epic> {
-    let conn = require_db();
-    let repo = crate::commands::db_shim::EpicRepo::new(&conn);
-    repo.get(id).ok()
+// ── JSON file data access ──────────────────────────────────────────
+
+/// Get a single epic by ID from JSON files.
+fn get_epic(flow_dir: &PathBuf, id: &str) -> Option<Epic> {
+    flowctl_core::json_store::epic_read(flow_dir, id).ok()
 }
 
-/// Get a single task by ID from DB.
-fn get_task(_flow_dir: &PathBuf, id: &str) -> Option<Task> {
-    let conn = require_db();
-    let repo = crate::commands::db_shim::TaskRepo::new(&conn);
-    repo.get(id).ok()
+/// Get a single task by ID from JSON files.
+fn get_task(flow_dir: &PathBuf, id: &str) -> Option<Task> {
+    flowctl_core::json_store::task_read(flow_dir, id).ok()
 }
 
-/// Get all tasks for an epic from DB.
-fn get_epic_tasks(_flow_dir: &PathBuf, epic_id: &str) -> Vec<Task> {
-    let conn = require_db();
-    let repo = crate::commands::db_shim::TaskRepo::new(&conn);
-    repo.list_by_epic(epic_id).unwrap_or_default()
+/// Get all tasks for an epic from JSON files.
+fn get_epic_tasks(flow_dir: &PathBuf, epic_id: &str) -> Vec<Task> {
+    flowctl_core::json_store::task_list_by_epic(flow_dir, epic_id).unwrap_or_default()
 }
 
-/// Get all epics from DB.
-fn get_all_epics(_flow_dir: &PathBuf) -> Vec<Epic> {
-    let conn = require_db();
-    let repo = crate::commands::db_shim::EpicRepo::new(&conn);
-    repo.list(None).unwrap_or_default()
+/// Get all epics from JSON files.
+fn get_all_epics(flow_dir: &PathBuf) -> Vec<Epic> {
+    flowctl_core::json_store::epic_list(flow_dir).unwrap_or_default()
 }
 
-/// Get all tasks, optionally filtered, from DB.
+/// Get all tasks, optionally filtered, from JSON files.
 fn get_all_tasks(
-    _flow_dir: &PathBuf,
+    flow_dir: &PathBuf,
     epic_filter: Option<&str>,
     status_filter: Option<&str>,
     domain_filter: Option<&str>,
 ) -> Vec<Task> {
-    let conn = require_db();
-    let repo = crate::commands::db_shim::TaskRepo::new(&conn);
     match epic_filter {
         Some(epic_id) => {
-            let mut tasks = repo.list_by_epic(epic_id).unwrap_or_default();
+            let mut tasks = flowctl_core::json_store::task_list_by_epic(flow_dir, epic_id).unwrap_or_default();
+            if let Some(status) = status_filter {
+                tasks.retain(|t| t.status.to_string() == status);
+            }
+            if let Some(domain) = domain_filter {
+                tasks.retain(|t| t.domain.to_string() == domain);
+            }
+            tasks
+        }
+        None => {
+            let mut tasks = flowctl_core::json_store::task_list_all(flow_dir).unwrap_or_default();
             if let Some(status) = status_filter {
                 tasks.retain(|t| t.status.to_string() == status);
             }
@@ -170,7 +170,6 @@ fn get_all_tasks(
             }
             tasks
         }
-        None => repo.list_all(status_filter, domain_filter).unwrap_or_default(),
     }
 }
 
@@ -490,13 +489,11 @@ pub fn cmd_cat(id: String) {
             }
         }
     } else if is_task_id(&id) {
-        // Task body: read from DB (sole source of truth)
-        let conn = require_db();
-        let repo = crate::commands::db_shim::TaskRepo::new(&conn);
-        match repo.get_with_body(&id) {
-            Ok((_task, body)) => {
+        // Task body: read from JSON spec file
+        match flowctl_core::json_store::task_spec_read(&flow_dir, &id) {
+            Ok(body) => {
                 if body.is_empty() {
-                    error_exit(&format!("Task body not found in DB: {}", id));
+                    error_exit(&format!("Task spec not found: {}", id));
                 }
                 print!("{}", body);
             }
@@ -527,14 +524,12 @@ pub fn cmd_files(json_mode: bool, epic: String) {
     let mut ownership: std::collections::BTreeMap<String, Vec<String>> =
         std::collections::BTreeMap::new();
 
-    let conn = require_db();
     for task in &tasks {
         let mut task_files: Vec<String> = task.files.clone();
 
-        // Fallback: parse **Files:** from task body in DB if no structured files
+        // Fallback: parse **Files:** from task spec if no structured files
         if task_files.is_empty() {
-            let repo = crate::commands::db_shim::TaskRepo::new(&conn);
-            if let Ok((_t, body)) = repo.get_with_body(&task.id) {
+            if let Ok(body) = flowctl_core::json_store::task_spec_read(&flow_dir, &task.id) {
                 for line in body.lines() {
                     if let Some(rest) = line.strip_prefix("**Files:**") {
                         task_files = rest