agents: extract run_and_apply, eliminate dead split-plan.md

- Add run_and_apply() — combines run_one_agent + action application
  into one call. Used by daemon job_consolidation_agent and
  consolidate_full, which had identical run+apply loops.

- Port split_plan_prompt() to use split.agent via defs::resolve_placeholders
  instead of loading the separate split-plan.md template. Make
  resolve_placeholders public for this.

- Delete prompts/split-plan.md — superseded by agents/split.agent
  which was already the canonical definition.

poc-memory/src/agents/consolidate.rs

@@ -83,7 +83,7 @@ pub fn consolidate_full_with_progress(
             *store = Store::load()?;
         }
 
-        let result = match knowledge::run_one_agent(store, agent_type, *count, "consolidate") {
+        let (total, applied) = match knowledge::run_and_apply(store, agent_type, *count, "consolidate") {
             Ok(r) => r,
             Err(e) => {
                 let msg = format!("  ERROR: {}", e);
@@ -93,19 +93,10 @@ pub fn consolidate_full_with_progress(
                 continue;
             }
         };
-
-        let ts = store::compact_timestamp();
-        let mut applied = 0;
-        for action in &result.actions {
-            if knowledge::apply_action(store, action, agent_type, &ts, 0) {
-                applied += 1;
-            }
-        }
-        total_actions += result.actions.len();
+        total_actions += total;
         total_applied += applied;
 
-        let msg = format!("  Done: {} actions ({} applied, {} no-ops)",
-            result.actions.len(), applied, result.no_ops);
+        let msg = format!("  Done: {} actions ({} applied)", total, applied);
         log_line(&mut log_buf, &msg);
         on_progress(&msg);
         println!("{}", msg);
@@ -246,7 +237,7 @@ pub fn apply_consolidation(store: &mut Store, do_apply: bool, report_key: Option
         return Ok(());
     }
 
-    let ts = store::format_datetime(store::now_epoch()).replace([':', '-', 'T'], "");
+    let ts = store::compact_timestamp();
     let mut applied = 0;
     for action in &all_actions {
         if knowledge::apply_action(store, action, "consolidate", &ts, 0) {

poc-memory/src/agents/daemon.rs

@@ -118,7 +118,6 @@ fn job_fact_mine(ctx: &ExecutionContext, path: &str) -> Result<(), TaskError> {
 }
 
 /// Run a single consolidation agent (replay, linker, separator, transfer, health).
-/// Builds prompt, calls Sonnet, stores report node in the store.
 fn job_consolidation_agent(
     ctx: &ExecutionContext,
     agent_type: &str,
@@ -129,19 +128,9 @@ fn job_consolidation_agent(
     run_job(ctx, &format!("c-{}", agent), || {
         ctx.log_line("loading store");
         let mut store = crate::store::Store::load()?;
-
         ctx.log_line(&format!("running agent: {} (batch={})", agent, batch));
-        let result = super::knowledge::run_one_agent(&mut store, &agent, batch, "consolidate")?;
-
-        let ts = crate::store::compact_timestamp();
-        let mut applied = 0;
-        for action in &result.actions {
-            if super::knowledge::apply_action(&mut store, action, &agent, &ts, 0) {
-                applied += 1;
-            }
-        }
-
-        ctx.log_line(&format!("done: {} actions ({} applied)", result.actions.len(), applied));
+        let (total, applied) = super::knowledge::run_and_apply(&mut store, &agent, batch, "consolidate")?;
+        ctx.log_line(&format!("done: {} actions ({} applied)", total, applied));
         Ok(())
     })
 }

poc-memory/src/agents/defs.rs

@@ -184,7 +184,7 @@ fn resolve(
 
 /// Resolve all {{placeholder}} patterns in a prompt template.
 /// Returns the resolved text and all node keys collected from placeholders.
-fn resolve_placeholders(
+pub fn resolve_placeholders(
     template: &str,
     store: &Store,
     graph: &Graph,

poc-memory/src/agents/knowledge.rs

@@ -332,6 +332,26 @@ pub struct AgentResult {
     pub node_keys: Vec<String>,
 }
 
+/// Run a single agent and apply its actions (no depth tracking).
+///
+/// Returns (total_actions, applied_count) or an error.
+pub fn run_and_apply(
+    store: &mut Store,
+    agent_name: &str,
+    batch_size: usize,
+    llm_tag: &str,
+) -> Result<(usize, usize), String> {
+    let result = run_one_agent(store, agent_name, batch_size, llm_tag)?;
+    let ts = store::compact_timestamp();
+    let mut applied = 0;
+    for action in &result.actions {
+        if apply_action(store, action, agent_name, &ts, 0) {
+            applied += 1;
+        }
+    }
+    Ok((result.actions.len(), applied))
+}
+
 /// Run a single agent: build prompt → call LLM → store output → parse actions → record visits.
 ///
 /// This is the common pipeline shared by the knowledge loop, consolidation pipeline,

poc-memory/src/agents/prompts.rs

@@ -366,12 +366,16 @@ pub fn format_split_plan_node(store: &Store, graph: &Graph, key: &str) -> String
     out
 }
 
-/// Build split-plan prompt for a single node (phase 1)
+/// Build split-plan prompt for a single node (phase 1).
+/// Uses the split.agent template with placeholders resolved for the given key.
 pub fn split_plan_prompt(store: &Store, key: &str) -> Result<String, String> {
+    let def = super::defs::get_def("split")
+        .ok_or_else(|| "no split.agent file".to_string())?;
     let graph = store.build_graph();
-    let topology = format_topology_header(&graph);
-    let node_section = format_split_plan_node(store, &graph, key);
-    load_prompt("split-plan", &[("{{TOPOLOGY}}", &topology), ("{{NODE}}", &node_section)])
+    // Override the query — we have a specific key to split
+    let keys = vec![key.to_string()];
+    let (prompt, _) = super::defs::resolve_placeholders(&def.prompt, store, &graph, &keys, 1);
+    Ok(prompt)
 }
 
 /// Build split-extract prompt for one child (phase 2)