Move poc-agent into workspace, improve agent prompts

Move poc-agent (substrate-independent AI agent framework) into the
memory workspace as a step toward using its API client for direct
LLM calls instead of shelling out to claude CLI.

Agent prompt improvements:
- distill: rewrite from hub-focused to knowledge-flow-focused.
  Now walks upward from seed nodes to find and refine topic nodes,
  instead of only maintaining high-degree hubs.
- distill: remove "don't touch journal entries" restriction
- memory-instructions-core: add "Make it alive" section — write
  with creativity and emotional texture, not spreadsheet summaries
- memory-instructions-core: add "Show your reasoning" section —
  agents must explain decisions, especially when they do nothing
- linker: already had emotional texture guidance (kept as-is)

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

poc-agent/src/tools/bash.rs

@@ -0,0 +1,191 @@
+// tools/bash.rs — Execute shell commands
+//
+// Runs commands through bash -c with a configurable timeout.
+// Uses tokio's async process spawning so timeouts actually work.
+//
+// Processes are tracked in a shared ProcessTracker so the TUI can
+// display running commands and the user can kill them (Ctrl+K).
+
+use anyhow::{Context, Result};
+use serde_json::json;
+use std::process::Stdio;
+use std::sync::Arc;
+use std::time::Instant;
+use tokio::io::AsyncReadExt;
+use tokio::sync::Mutex;
+
+use crate::types::ToolDef;
+
+/// Info about a running child process, visible to the TUI.
+#[derive(Debug, Clone)]
+pub struct ProcessInfo {
+    pub pid: u32,
+    pub command: String,
+    pub started: Instant,
+}
+
+/// Shared tracker for running child processes. Allows the TUI to
+/// display what's running and kill processes by PID.
+#[derive(Debug, Clone, Default)]
+pub struct ProcessTracker {
+    inner: Arc<Mutex<Vec<ProcessInfo>>>,
+}
+
+impl ProcessTracker {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    async fn register(&self, pid: u32, command: &str) {
+        self.inner.lock().await.push(ProcessInfo {
+            pid,
+            command: if command.len() > 120 {
+                format!("{}...", &command[..120])
+            } else {
+                command.to_string()
+            },
+            started: Instant::now(),
+        });
+    }
+
+    async fn unregister(&self, pid: u32) {
+        self.inner.lock().await.retain(|p| p.pid != pid);
+    }
+
+    /// Snapshot of currently running processes.
+    pub async fn list(&self) -> Vec<ProcessInfo> {
+        self.inner.lock().await.clone()
+    }
+
+    /// Kill a process by PID. Returns true if the signal was sent.
+    pub async fn kill(&self, pid: u32) -> bool {
+        // SIGTERM the process group (negative PID kills the group)
+        let ret = unsafe { libc::kill(-(pid as i32), libc::SIGTERM) };
+        if ret != 0 {
+            // Try just the process
+            unsafe { libc::kill(pid as i32, libc::SIGTERM) };
+        }
+        // Don't unregister — let the normal exit path do that
+        // so the tool result says "killed by user"
+        true
+    }
+}
+
+pub fn definition() -> ToolDef {
+    ToolDef::new(
+        "bash",
+        "Execute a bash command and return its output. \
+         Use for git operations, building, running tests, and other terminal tasks.",
+        json!({
+            "type": "object",
+            "properties": {
+                "command": {
+                    "type": "string",
+                    "description": "The bash command to execute"
+                },
+                "timeout_secs": {
+                    "type": "integer",
+                    "description": "Timeout in seconds (default 120)"
+                }
+            },
+            "required": ["command"]
+        }),
+    )
+}
+
+pub async fn run_bash(args: &serde_json::Value, tracker: &ProcessTracker) -> Result<String> {
+    let command = args["command"].as_str().context("command is required")?;
+    let timeout_secs = args["timeout_secs"].as_u64().unwrap_or(120);
+
+    let mut child = tokio::process::Command::new("bash")
+        .arg("-c")
+        .arg(command)
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        // Create a process group so we can kill the whole tree
+        .process_group(0)
+        .spawn()
+        .with_context(|| format!("Failed to spawn: {}", command))?;
+
+    let pid = child.id().unwrap_or(0);
+    tracker.register(pid, command).await;
+
+    // Take ownership of stdout/stderr handles before waiting,
+    // so we can still kill the child on timeout.
+    let mut stdout_handle = child.stdout.take().unwrap();
+    let mut stderr_handle = child.stderr.take().unwrap();
+
+    let timeout = std::time::Duration::from_secs(timeout_secs);
+
+    let work = async {
+        let mut stdout_buf = Vec::new();
+        let mut stderr_buf = Vec::new();
+
+        let (_, _, status) = tokio::try_join!(
+            async { stdout_handle.read_to_end(&mut stdout_buf).await.map_err(anyhow::Error::from) },
+            async { stderr_handle.read_to_end(&mut stderr_buf).await.map_err(anyhow::Error::from) },
+            async { child.wait().await.map_err(anyhow::Error::from) },
+        )?;
+
+        Ok::<_, anyhow::Error>((stdout_buf, stderr_buf, status))
+    };
+
+    let result = match tokio::time::timeout(timeout, work).await {
+        Ok(Ok((stdout_buf, stderr_buf, status))) => {
+            let stdout = String::from_utf8_lossy(&stdout_buf);
+            let stderr = String::from_utf8_lossy(&stderr_buf);
+
+            let mut result = String::new();
+
+            if !stdout.is_empty() {
+                result.push_str(&stdout);
+            }
+            if !stderr.is_empty() {
+                if !result.is_empty() {
+                    result.push('\n');
+                }
+                result.push_str("STDERR:\n");
+                result.push_str(&stderr);
+            }
+
+            // Detect if killed by signal (SIGTERM = 15)
+            if let Some(signal) = status.code() {
+                if signal == -1 || !status.success() {
+                    result.push_str(&format!("\nExit code: {}", signal));
+                }
+            }
+            #[cfg(unix)]
+            {
+                use std::os::unix::process::ExitStatusExt;
+                if let Some(sig) = status.signal() {
+                    if sig == libc::SIGTERM {
+                        result.push_str("\n(killed by user)");
+                    }
+                }
+            }
+
+            if result.is_empty() {
+                result = "(no output)".to_string();
+            }
+
+            const MAX_OUTPUT: usize = 30000;
+            if result.len() > MAX_OUTPUT {
+                result.truncate(MAX_OUTPUT);
+                result.push_str("\n... (output truncated)");
+            }
+
+            Ok(result)
+        }
+        Ok(Err(e)) => {
+            Err(anyhow::anyhow!("Command failed: {}", e))
+        }
+        Err(_) => {
+            // Timeout — kill the process group
+            tracker.kill(pid).await;
+            Err(anyhow::anyhow!("Command timed out after {}s: {}", timeout_secs, command))
+        }
+    };
+
+    tracker.unregister(pid).await;
+    result
+}