agents: always use API backend, remove tools field from .agent files

- Remove is_split special case in daemon — split now goes through
  job_consolidation_agent like all other agents
- call_for_def uses API whenever api_base_url is configured, regardless
  of tools field (was requiring non-empty tools to use API)
- Remove "tools" field from all .agent files — memory tools are always
  provided by the API layer, not configured per-agent
- Add prompt size guard: reject prompts over 800KB (~200K tokens) with
  clear error instead of hitting the model's context limit

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

poc-memory/src/agents/daemon.rs

@@ -1189,7 +1189,6 @@ pub fn run_daemon() -> Result<(), String> {
             let mut remaining = count;
 
             let is_rename = *agent_type == "rename";
-            let is_split = *agent_type == "split";
 
             // Targeted run: one task for a specific node
             if let Some(ref key) = target_key {
@@ -1212,29 +1211,6 @@ pub fn run_daemon() -> Result<(), String> {
                 remaining = 0;
             }
 
-            if is_split {
-                let store = crate::store::Store::load().ok();
-                let candidates = store.as_ref()
-                    .map(|s| super::prompts::split_candidates(s))
-                    .unwrap_or_default();
-                let to_split: Vec<String> = candidates.into_iter()
-                    .take(count)
-                    .collect();
-                for key in &to_split {
-                    let key = key.clone();
-                    let task_name = format!("c-split-{}:{}", key, today);
-                    choir_rpc.spawn(task_name)
-                        .resource(&llm_rpc)
-                        .retries(1)
-                        .init(move |ctx| {
-                            job_split_one(ctx, key.clone())
-                        })
-                        .run();
-                    spawned += 1;
-                }
-                remaining = 0;
-            }
-
             while remaining > 0 {
                 let batch = remaining.min(batch_size);
                 let agent = agent_type.to_string();

poc-memory/src/agents/knowledge.rs

@@ -138,6 +138,16 @@ fn run_one_agent_inner(
         else { format!("{} tools", def.tools.len()) };
     log(&format!("prompt {}KB, model={}, {}, {} nodes",
         prompt_kb, def.model, tools_desc, agent_batch.node_keys.len()));
+
+    // Guard: reject prompts that would exceed model context.
+    // Rough estimate: 1 token ≈ 4 bytes. Reserve 16K tokens for output.
+    let max_prompt_bytes = 800_000; // ~200K tokens, leaves room for output
+    if agent_batch.prompt.len() > max_prompt_bytes {
+        return Err(format!(
+            "prompt too large: {}KB (max {}KB) — seed nodes may be oversized",
+            prompt_kb, max_prompt_bytes / 1024,
+        ));
+    }
     for key in &agent_batch.node_keys {
         log(&format!("  node: {}", key));
     }

poc-memory/src/agents/llm.rs

@@ -188,7 +188,7 @@ pub(crate) fn call_haiku(agent: &str, prompt: &str) -> Result<String, String> {
 /// otherwise falls back to claude CLI subprocess.
 pub(crate) fn call_for_def(def: &super::defs::AgentDef, prompt: &str) -> Result<String, String> {
     let config = crate::config::get();
-    if config.api_base_url.is_some() && !def.tools.is_empty() {
+    if config.api_base_url.is_some() {
         super::daemon::log_verbose(&def.agent, "llm-backend",
             &format!("API: {}", config.api_base_url.as_deref().unwrap_or("?")));
         let log = |msg: &str| eprintln!("[{}] {}", def.agent, msg);