fix: energy starvation — distribute ticks to agents only, remove root exemption

Agents were receiving 0 energy per tick because root's energy_share (100.0)
dominated the total, causing floor() to round smaller shares to 0.

- Energy distribution now filters by actor_type='agent' (zero DB migration)
- Removed hardcoded root lifecycle exemption (root follows lineage checks)
- Added update_energy_share lifecycle operation for runtime share adjustment
- Added is_finite() validation to prevent NaN/Infinity poisoning
- Windows IPC: file-path pipe (\.\pipe\punkgo-kernel) fixes Access Denied
- Daemon PID lockfile with duplicate instance detection
- Bumped to 0.3.0

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: FeilixX

CHANGELOG.md

@@ -5,6 +5,26 @@ All notable changes to PunkGo Kernel will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.0] - 2026-03-13
+
+### Fixed
+
+- **Energy starvation bug** — agents received 0 energy per tick due to `floor()` rounding when root's `energy_share` dominated the total. Distribution now targets agents only (`actor_type = 'agent'`); humans receive one-time initial balance
+- **Windows IPC "Access Denied"** — default endpoint changed to file-path pipe (`\\.\pipe\punkgo-kernel`) to avoid `GenericNamespaced` permission issues
+- **NaN/Infinity validation** — `update_energy_share` rejects non-finite values that would poison tick distribution
+
+### Added
+
+- **`update_energy_share` lifecycle operation** — runtime adjustment of an agent's energy share via `mutate` action
+- **PID lockfile** (`daemon.pid`) — daemon startup detects and prompts to kill existing instances
+- **`PUNKGO_IPC_ENDPOINT` env var** — override the default IPC endpoint
+
+### Changed
+
+- **Root is genesis-only** — removed hardcoded root exemption from lifecycle authorization; root now follows lineage-based checks like any human
+- **Root default `energy_share`** — 100.0 → 0.0 for new databases (existing databases unaffected due to `ON CONFLICT DO NOTHING`)
+- **PIP-001 §3** — clarified that share distribution applies to agents only
+
 ## [0.2.1] - 2026-02-22
 
 ### Fixed

Cargo.lock

@@ -7,7 +7,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "0.2.9"
+version = "0.3.0"
 edition = "2024"
 authors = ["Felix <feijiu@punkgo.ai>"]
 license = "MIT"

Cargo.toml

@@ -54,7 +54,7 @@ Every action goes through a **7-step pipeline**:
 
 ### Energy System
 
-Energy is produced continuously, anchored to the machine's hardware compute power (INT8 TOPS). Each tick, energy is distributed proportionally among active actors based on their shares. The kernel itself holds no energy (energy neutrality).
+Energy is produced continuously, anchored to the machine's hardware compute power (INT8 TOPS). Each tick, energy is distributed proportionally among active **agents** based on their shares. Humans (including root) receive a one-time initial balance but do not participate in tick-based distribution. The kernel itself holds no energy (energy neutrality).
 
 ### Actor Model
 

README.md

@@ -107,14 +107,16 @@ pub struct CreateActorSpec {
 // ---------------------------------------------------------------------------
 
 /// Phase 4a: Lifecycle operations that can be performed on actors.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum LifecycleOp {
     /// Freeze an actor — suspends all state-changing actions.
     Freeze { reason: Option<String> },
     /// Unfreeze — restores an actor to active.
     Unfreeze,
     /// Terminate — permanently removes an agent (creates orphans).
     Terminate { reason: Option<String> },
+    /// Update an actor's energy_share for tick-based distribution.
+    UpdateEnergyShare { energy_share: f64 },
 }
 
 // ---------------------------------------------------------------------------

crates/punkgo-core/src/actor.rs

@@ -17,7 +17,7 @@ default = []
 testkit = []
 
 [dependencies]
-punkgo-core = { path = "../punkgo-core", version = "0.2.9" }
+punkgo-core = { path = "../punkgo-core", version = "0.3.0" }
 anyhow.workspace = true
 async-trait.workspace = true
 serde.workspace = true

crates/punkgo-kernel/Cargo.toml

@@ -10,6 +10,7 @@
 //! 3. Listens for IPC connections and dispatches requests to [`Kernel::handle_request`]
 //! 4. On CTRL-C: signals the energy producer to stop, aborts the IPC server, and exits
 
+use std::path::PathBuf;
 use std::sync::Arc;
 
 use anyhow::Result;
@@ -27,6 +28,11 @@ async fn main() -> Result<()> {
         .init();
 
     let config = KernelConfig::default();
+
+    // Acquire PID lockfile — prevents multiple daemons and detects stale pipes.
+    let lockfile = config.state_dir.join("daemon.pid");
+    check_and_acquire_lock(&lockfile)?;
+
     let kernel = Arc::new(Kernel::bootstrap(&config).await?);
     info!(state_dir = %config.state_dir.display(), "kernel bootstrapped");
 
@@ -45,6 +51,7 @@ async fn main() -> Result<()> {
     });
 
     let endpoint = config.ipc_endpoint.clone();
+    info!(endpoint = %endpoint, "IPC endpoint resolved");
     let kernel_for_server = Arc::clone(&kernel);
     let mut server =
         tokio::spawn(async move { ipc::run_ipc_server(kernel_for_server, &endpoint).await });
@@ -81,6 +88,79 @@ async fn main() -> Result<()> {
         }
     }
 
+    // Clean up lockfile on graceful shutdown.
+    let _ = std::fs::remove_file(&lockfile);
     drop(kernel);
     Ok(())
 }
+
+/// Check for existing daemon via PID lockfile. If a stale lock exists (process
+/// dead), prompt the user to confirm cleanup.
+fn check_and_acquire_lock(lockfile: &std::path::Path) -> Result<()> {
+    if lockfile.exists() {
+        let content = std::fs::read_to_string(lockfile).unwrap_or_default();
+        let old_pid: u32 = content.trim().parse().unwrap_or(0);
+
+        if old_pid > 0 && is_process_alive(old_pid) {
+            eprintln!("Another punkgo-kerneld is running (PID {old_pid}).");
+            eprintln!();
+            eprint!("Kill it and continue? [y/N] ");
+            let mut input = String::new();
+            std::io::stdin().read_line(&mut input)?;
+            if input.trim().eq_ignore_ascii_case("y") || input.trim().eq_ignore_ascii_case("yes") {
+                kill_process(old_pid);
+                std::thread::sleep(std::time::Duration::from_secs(2));
+            } else {
+                eprintln!("Aborted.");
+                std::process::exit(1);
+            }
+        } else {
+            // Stale lockfile — old daemon crashed. Clean up silently.
+            info!(old_pid, "removing stale lockfile");
+        }
+    }
+
+    // Write our PID.
+    std::fs::write(lockfile, std::process::id().to_string())?;
+    Ok(())
+}
+
+fn is_process_alive(pid: u32) -> bool {
+    #[cfg(windows)]
+    {
+        let output = std::process::Command::new("tasklist")
+            .args(["/FI", &format!("PID eq {pid}"), "/FO", "CSV", "/NH"])
+            .output();
+        match output {
+            Ok(out) => {
+                let text = String::from_utf8_lossy(&out.stdout);
+                // CSV format: "process.exe","PID","...". Check for exact PID field.
+                text.contains(&format!("\"{pid}\""))
+            }
+            Err(_) => false,
+        }
+    }
+    #[cfg(not(windows))]
+    {
+        std::process::Command::new("kill")
+            .args(["-0", &pid.to_string()])
+            .status()
+            .map(|s| s.success())
+            .unwrap_or(false)
+    }
+}
+
+fn kill_process(pid: u32) {
+    #[cfg(windows)]
+    {
+        let _ = std::process::Command::new("taskkill")
+            .args(["/F", "/PID", &pid.to_string()])
+            .output();
+    }
+    #[cfg(not(windows))]
+    {
+        let _ = std::process::Command::new("kill")
+            .args(["-9", &pid.to_string()])
+            .output();
+    }
+}

crates/punkgo-kernel/src/daemon/main.rs

@@ -85,7 +85,7 @@ impl EnergyProducer {
 
     /// Execute a single production tick. Public for testing.
     pub async fn produce_tick(&self, energy_per_tick: i64) -> Result<TickResult, String> {
-        // 1. Query all active actors with energy_share > 0
+        // 1. Query all active agents with energy_share > 0 (humans excluded)
         let actors = self
             .actor_store
             .list_active_with_shares()

crates/punkgo-kernel/src/runtime/energy_producer.rs

@@ -35,16 +35,31 @@ impl Default for KernelConfig {
         let state_dir = std::env::var("PUNKGO_STATE_DIR")
             .map(PathBuf::from)
             .unwrap_or_else(|_| default_state_dir());
+        let ipc_endpoint = std::env::var("PUNKGO_IPC_ENDPOINT")
+            .unwrap_or_else(|_| default_ipc_endpoint());
         Self {
             state_dir,
-            ipc_endpoint: "punkgo-kernel".to_string(),
+            ipc_endpoint,
         }
     }
 }
 
 /// Default state directory: ~/.punkgo/state
 ///
 /// Falls back to `./state` if home directory cannot be determined.
+/// Default IPC endpoint.
+///
+/// On Windows, uses a file-path named pipe (`\\.\pipe\punkgo-kernel`) because
+/// the `GenericNamespaced` namespace can hit "Access Denied" depending on
+/// Windows security policy. On Unix, uses a simple namespace name.
+fn default_ipc_endpoint() -> String {
+    if cfg!(windows) {
+        r"\\.\pipe\punkgo-kernel".to_string()
+    } else {
+        "punkgo-kernel".to_string()
+    }
+}
+
 fn default_state_dir() -> PathBuf {
     if let Some(home) = home_dir() {
         return home.join(".punkgo").join("state");
@@ -641,6 +656,27 @@ impl Kernel {
                         }
                     }
                 }
+                punkgo_core::actor::LifecycleOp::UpdateEnergyShare { energy_share } => {
+                    match lifecycle::execute_update_energy_share(
+                        &self.actor_store,
+                        &pool,
+                        target_actor_id,
+                        *energy_share,
+                    )
+                    .await
+                    {
+                        Ok(()) => {
+                            info!(
+                                target = %target_actor_id,
+                                energy_share,
+                                "lifecycle: energy_share updated"
+                            );
+                        }
+                        Err(err) => {
+                            warn!(error = %err, "lifecycle: update_energy_share failed (event already committed)");
+                        }
+                    }
+                }
             }
         }
 

crates/punkgo-kernel/src/runtime/kernel.rs

@@ -38,6 +38,10 @@ pub fn parse_lifecycle_op(
         "freeze" => LifecycleOp::Freeze { reason },
         "unfreeze" => LifecycleOp::Unfreeze,
         "terminate" => LifecycleOp::Terminate { reason },
+        "update_energy_share" => {
+            let energy_share = payload.get("energy_share")?.as_f64()?;
+            LifecycleOp::UpdateEnergyShare { energy_share }
+        }
         _ => return None,
     };
 
@@ -51,9 +55,8 @@ pub fn parse_lifecycle_op(
 ///
 /// | Initiator  | Target     | Allowed |
 /// |-----------|------------|---------|
-/// | human     | own agent  | yes     |
+/// | human     | own agent  | yes (lineage check)  |
 /// | agent     | any        | no      |
-/// | root      | any agent  | yes     |
 pub async fn validate_lifecycle_authorization(
     initiator: &ActorRecord,
     target: &ActorRecord,
@@ -66,11 +69,6 @@ pub async fn validate_lifecycle_authorization(
         ));
     }
 
-    // Root can do anything
-    if initiator.actor_id == "root" {
-        return Ok(());
-    }
-
     // PIP-001 §5: Agents cannot manage other agents.
     if initiator.actor_type == ActorType::Agent {
         return Err(KernelError::PolicyViolation(format!(
@@ -144,6 +142,21 @@ pub async fn execute_unfreeze(
     Ok(())
 }
 
+/// Execute an update_energy_share operation: change the target's energy_share.
+pub async fn execute_update_energy_share(
+    actor_store: &ActorStore,
+    pool: &sqlx::SqlitePool,
+    target_id: &str,
+    energy_share: f64,
+) -> KernelResult<()> {
+    let mut tx = pool.begin().await?;
+    actor_store
+        .update_energy_share_in_tx(&mut tx, target_id, energy_share)
+        .await?;
+    tx.commit().await?;
+    Ok(())
+}
+
 /// Check existence conditions for an actor (PIP-001 §7).
 ///
 /// Four conditions that must hold for an actor to exist:
@@ -176,6 +189,29 @@ mod tests {
     use super::*;
     use serde_json::json;
 
+    #[test]
+    fn parse_update_energy_share_op() {
+        let (id, op) = parse_lifecycle_op(
+            "actor/agent-1",
+            &json!({"op": "update_energy_share", "energy_share": 42.5}),
+        )
+        .expect("should parse");
+        assert_eq!(id, "agent-1");
+        assert!(
+            matches!(op, LifecycleOp::UpdateEnergyShare { energy_share } if (energy_share - 42.5).abs() < f64::EPSILON)
+        );
+    }
+
+    #[test]
+    fn parse_update_energy_share_missing_value() {
+        let result =
+            parse_lifecycle_op("actor/agent-1", &json!({"op": "update_energy_share"}));
+        assert!(
+            result.is_none(),
+            "missing energy_share value should return None"
+        );
+    }
+
     #[test]
     fn parse_freeze_op() {
         let (id, op) =