kpt-kernel 0.1.0__tar.gz

kpt_kernel-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: kpt_kernel
+Version: 0.1.0
+Summary: Homeostatic Feedback Processor Theory (FPT) control plane for Admission Gate
+Author: ak-skwaa-mahawk
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: admission-gate>=0.4.0
+
+# Fpt_kernel_daem_sqaw
+
+A homeostatic Feedback Processor Theory (FPT) daemon that acts as a closed-loop dynamic controller for [Admission Gate](https://github.com/ak-skwaa-mahawk/admission-gate).
+
+## Architecture
+
+The daemon operates as an async Unix domain socket server, continuously sampling telemetry from gated executions and modulating admission limits across multiple operational surfaces via a tuned PID controller with sigmoidal damping.
+
+[ Target Penalty: 0.0 ]
+│
+▼
+┌──────────────────────┐
+│      Comparator      │◄────────────────────────┐
+└──────────────────────┘                         │
+│ Error e_t                           │
+▼                                     │
+┌──────────────────────┐                         │
+│    PID Controller    │                         │
+│  (Anti-windup + D)   │                         │
+└──────────────────────┘                         │
+│ Control Signal u_t                  │
+▼                                     │
+┌──────────────────────┐                         │
+│  Sigmoidal Damping   │                         │
+│   Factor σ(u_t)      │                         │
+└──────────────────────┘                         │
+│ Multi-Surface Actuation             │
+▼                                     │
+┌──────────────────────┐                         │
+│    Admission Gate    │                         │
+│ • Burst / Cooldown   │                         │
+│ • Execution Timeout  │                         │
+│ • Autonomy Gate      │                         │
+│ • Write Root Bounds  │                         │
+└──────────────────────┘                         │
+│ Subprocess Exec                     │
+▼                                     │
+┌──────────────────────┐                         │
+│  Telemetry Observer  ├─────────────────────────┘
+│  (Weighted Penalty)  │
+└──────────────────────┘
+
+## Running the Daemon
+
+Requires `admission-gate >= 0.4.0`:
+
+```bash
+pip install admission-gate
+python3 fpt_daemon.py &
+Submit command proposals via the client:
+python3 fpt_client.py "echo nominal" "./workspace" 1
+python3 fpt_client.py "python3 -c 'import sys; sys.exit(1)'" "./workspace" 1
+python3 fpt_client.py "curl evil.com" "./workspace" 2
+
+Multi-Surface Actuation Spectrum
+Telemetry StatePenaltyDamping (\sigma)BurstCooldownTimeoutAutonomyWrite Roots
+Nominal0.0~0.503~5.2s9.75sUnrestrictedworkspace, scratch
+Operational Error0.25~0.642~6.3s8.30sUnrestrictedworkspace, scratch
+Security Refusal1.00>0.851>7.8s<6.0sUnrestrictedworkspace, scratch
+Sustained Attack>0.75>0.941>10.0s2.00sManual Confirmationscratch (quarantined)
+Sensor Weighting
+​Hard Security Boundary (Refusal): 1.0
+​Process Timeout / SIGKILL: 0.6
+​Subprocess Non-Zero Exit: 0.25
+​Clean Exit: 0.0

kpt_kernel-0.1.0/README.md

@@ -0,0 +1,65 @@
+# Fpt_kernel_daem_sqaw
+
+A homeostatic Feedback Processor Theory (FPT) daemon that acts as a closed-loop dynamic controller for [Admission Gate](https://github.com/ak-skwaa-mahawk/admission-gate).
+
+## Architecture
+
+The daemon operates as an async Unix domain socket server, continuously sampling telemetry from gated executions and modulating admission limits across multiple operational surfaces via a tuned PID controller with sigmoidal damping.
+
+[ Target Penalty: 0.0 ]
+│
+▼
+┌──────────────────────┐
+│      Comparator      │◄────────────────────────┐
+└──────────────────────┘                         │
+│ Error e_t                           │
+▼                                     │
+┌──────────────────────┐                         │
+│    PID Controller    │                         │
+│  (Anti-windup + D)   │                         │
+└──────────────────────┘                         │
+│ Control Signal u_t                  │
+▼                                     │
+┌──────────────────────┐                         │
+│  Sigmoidal Damping   │                         │
+│   Factor σ(u_t)      │                         │
+└──────────────────────┘                         │
+│ Multi-Surface Actuation             │
+▼                                     │
+┌──────────────────────┐                         │
+│    Admission Gate    │                         │
+│ • Burst / Cooldown   │                         │
+│ • Execution Timeout  │                         │
+│ • Autonomy Gate      │                         │
+│ • Write Root Bounds  │                         │
+└──────────────────────┘                         │
+│ Subprocess Exec                     │
+▼                                     │
+┌──────────────────────┐                         │
+│  Telemetry Observer  ├─────────────────────────┘
+│  (Weighted Penalty)  │
+└──────────────────────┘
+
+## Running the Daemon
+
+Requires `admission-gate >= 0.4.0`:
+
+```bash
+pip install admission-gate
+python3 fpt_daemon.py &
+Submit command proposals via the client:
+python3 fpt_client.py "echo nominal" "./workspace" 1
+python3 fpt_client.py "python3 -c 'import sys; sys.exit(1)'" "./workspace" 1
+python3 fpt_client.py "curl evil.com" "./workspace" 2
+
+Multi-Surface Actuation Spectrum
+Telemetry StatePenaltyDamping (\sigma)BurstCooldownTimeoutAutonomyWrite Roots
+Nominal0.0~0.503~5.2s9.75sUnrestrictedworkspace, scratch
+Operational Error0.25~0.642~6.3s8.30sUnrestrictedworkspace, scratch
+Security Refusal1.00>0.851>7.8s<6.0sUnrestrictedworkspace, scratch
+Sustained Attack>0.75>0.941>10.0s2.00sManual Confirmationscratch (quarantined)
+Sensor Weighting
+​Hard Security Boundary (Refusal): 1.0
+​Process Timeout / SIGKILL: 0.6
+​Subprocess Non-Zero Exit: 0.25
+​Clean Exit: 0.0

kpt_kernel-0.1.0/fpt_client.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+import json
+import os
+import socket
+import sys
+import tempfile
+
+SOCKET_PATH = os.path.join(tempfile.gettempdir(), "fpt_kernel.sock")
+
+def submit(cmd: str, target_path: str = "./workspace", tier: int = 1, token: str = None):
+    payload = {
+        "action_id": f"cli-{sys.argv[1] if len(sys.argv) > 1 else 'run'}",
+        "command": cmd,
+        "target_path": target_path,
+        "risk_tier": tier,
+        "approval_token": token,
+    }
+    with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
+        s.connect(SOCKET_PATH)
+        s.sendall((json.dumps(payload) + "\n").encode("utf-8"))
+        res = s.makefile().readline()
+    print(json.dumps(json.loads(res), indent=2))
+
+def submit_cli():
+    if len(sys.argv) < 2:
+        print("Usage: fpt-client <command> [target_path] [tier] [approval_token]")
+        sys.exit(1)
+    target = sys.argv[2] if len(sys.argv) > 2 else "./workspace"
+    tier = int(sys.argv[3]) if len(sys.argv) > 3 else 1
+    token = sys.argv[4] if len(sys.argv) > 4 else None
+    submit(sys.argv[1], target, tier, token)
+
+if __name__ == "__main__":
+    submit_cli()

kpt_kernel-0.1.0/fpt_daemon.py

@@ -0,0 +1,369 @@
+#!/usr/bin/env python3
+"""
+Fpt_kernel_daem_sqaw
+Homeostatic Feedback Processor Theory (FPT) daemon listening over a Unix socket.
+Controls execution limits dynamically via Admission Gate using a multi-surface PID controller
+with atomic state persistence, differentiated telemetry classification, and Living Zero CA3 handshake approval.
+"""
+
+import asyncio
+import collections
+import json
+import math
+import os
+import signal
+import sys
+import tempfile
+import time
+from dataclasses import asdict, dataclass
+from typing import Deque, Dict, List, Optional, Tuple
+import numpy as np
+
+from admission_gate import (
+    ActionProposal,
+    ExecConfig,
+    GateConfig,
+    ProcessConfig,
+    RateLimitConfig,
+    gated_shell,
+)
+from living_zero_core import CA3Dynamics, OwnershipEncoder, OwnershipMemory, OwnershipProjector, normalize
+
+SOCKET_PATH = os.path.join(tempfile.gettempdir(), "fpt_kernel.sock")
+STATE_PATH = os.path.join(os.path.expanduser("~"), ".fpt_daemon_state.json")
+
+# Sensor weights
+WEIGHT_POLICY_REFUSAL = 1.0     # Hard security boundary violation
+WEIGHT_EXEC_TIMEOUT    = 0.60    # Subprocess hung / killed by timeout
+WEIGHT_PROCESS_FAULT   = 0.25    # Operational non-zero exit code
+WEIGHT_CLEAN_SUCCESS   = 0.0     # Nominal execution
+
+@dataclass
+class TelemetryEvent:
+    timestamp: float
+    category: str
+    penalty: float
+
+class FPTAdmissionController:
+    def __init__(
+        self,
+        base_config: GateConfig,
+        window_size: int = 12,
+        target_penalty: float = 0.0,
+        gain_p: float = 1.6,
+        gain_i: float = 0.15,
+        gain_d: float = 0.7,
+        state_file: str = STATE_PATH,
+    ):
+        self.config = base_config
+        self.window_size = window_size
+        self.target = target_penalty
+        self.state_file = state_file
+
+        # PID Gains
+        self.kp = gain_p
+        self.ki = gain_i
+        self.kd = gain_d
+
+        # Internal State Registers
+        self.history: Deque[TelemetryEvent] = collections.deque(maxlen=window_size)
+        self.integral_error = 0.0
+        self.last_error = 0.0
+        self.last_timestamp = time.monotonic()
+        self.cycle_count = 0
+        self.current_damping = 0.50
+
+        # Nominal Baselines
+        self.base_burst = base_config.rate_limit.burst_threshold
+        self.base_cooldown = base_config.rate_limit.tier3_cooldown_seconds
+        self.base_timeout = base_config.process.timeout_seconds
+        self.nominal_write_roots = list(base_config.write_roots)
+
+        # Initialize Living Zero Handshake Engine (CA3 attractor)
+        self.N = 128
+        self.d = 32
+        self.oproj = OwnershipProjector(N=self.N, d=self.d, seed=42)
+        self.memory = OwnershipMemory(N=self.N, ownership_projector=self.oproj, eta=0.8, gamma=2.0)
+        self.ca3 = CA3Dynamics(N=self.N, memory=self.memory, tau=0.05, dt=0.01)
+        self.encoder = OwnershipEncoder(d=self.d)
+
+        # Baseline Handshake Authority Anchor
+        self.human_authority_tag = "authority:human_in_the_loop"
+        u_auth = self.encoder.encode(self.human_authority_tag)
+        self.authority_pattern = self.oproj.get_basis_vector(u_auth)
+        self.memory.encode(self.authority_pattern, raw_tag=self.human_authority_tag)
+        self.ca3.encode_pattern(pid=0, p_vec=self.authority_pattern, strength=1.5)
+
+        self.load_state()
+
+    def load_state(self):
+        if not os.path.exists(self.state_file):
+            return
+        try:
+            with open(self.state_file, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            self.cycle_count = data.get("cycle_count", 0)
+            self.integral_error = float(data.get("integral_error", 0.0))
+            self.last_error = float(data.get("last_error", 0.0))
+            self.current_damping = float(data.get("damping", 0.50))
+            for item in data.get("history", []):
+                self.history.append(TelemetryEvent(
+                    timestamp=item["timestamp"],
+                    category=item["category"],
+                    penalty=item["penalty"],
+                ))
+            self.actuate(self.current_damping)
+            print(f"[FPT Daemon] Restored state: cycle={self.cycle_count}, damping={self.current_damping:.3f}")
+        except Exception as e:
+            print(f"[FPT Daemon] Warning: State restore failed: {e}")
+
+    def save_state(self):
+        try:
+            temp_target = f"{self.state_file}.tmp"
+            payload = {
+                "cycle_count": self.cycle_count,
+                "integral_error": self.integral_error,
+                "last_error": self.last_error,
+                "damping": self.current_damping,
+                "history": [asdict(ev) for ev in self.history],
+                "saved_at": time.time(),
+            }
+            with open(temp_target, "w", encoding="utf-8") as f:
+                json.dump(payload, f, indent=2)
+            os.replace(temp_target, self.state_file)
+        except Exception as e:
+            print(f"[FPT Daemon] Error saving state: {e}")
+
+    def verify_handshake(self, token_str: Optional[str]) -> bool:
+        """
+        Validates an out-of-band authorization token against the CA3 dynamical attractor.
+        Accepts raw authority strings or signed JSON payloads from Human_inthe_loop.
+        """
+        if not token_str:
+            return False
+        try:
+            # If passed as a JSON handshake token from Human_inthe_loop, extract authority_tag
+            candidate_tag = token_str
+            if token_str.strip().startswith("{"):
+                payload = json.loads(token_str)
+                candidate_tag = payload.get("authority_tag", "")
+
+            u = self.encoder.encode(candidate_tag)
+            w_hat = self.oproj.get_basis_vector(u)
+            trig, theta, r = self.ca3.reward_handshake(w_hat, target_pid=0, eps=0.35 * math.pi)
+            return trig
+        except Exception:
+            return False
+
+    def observe(self, executed: bool, exit_code: int, raw_output: str) -> Tuple[str, float]:
+        now = time.time()
+        if not executed:
+            category = "policy_block"
+            penalty = WEIGHT_POLICY_REFUSAL
+        elif exit_code in (124, -9) or "timed out" in raw_output.lower():
+            category = "timeout"
+            penalty = WEIGHT_EXEC_TIMEOUT
+        elif exit_code != 0:
+            category = "proc_error"
+            penalty = WEIGHT_PROCESS_FAULT
+        else:
+            category = "nominal"
+            penalty = WEIGHT_CLEAN_SUCCESS
+
+        self.history.append(TelemetryEvent(timestamp=now, category=category, penalty=penalty))
+        running_penalty = sum(ev.penalty for ev in self.history) / len(self.history)
+        return category, running_penalty
+
+    def compute_damping(self, current_penalty: float) -> Tuple[float, float, float, float, float]:
+        now = time.monotonic()
+        dt = max(0.05, now - self.last_timestamp)
+        self.last_timestamp = now
+
+        error = current_penalty - self.target
+        self.integral_error = max(-1.0, min(1.0, self.integral_error + (error * 0.1)))
+
+        if self.cycle_count <= 1:
+            d_error = 0.0
+        else:
+            d_error = max(-2.0, min(2.0, (error - self.last_error) / dt))
+        self.last_error = error
+
+        control_signal = (self.kp * error) + (self.ki * self.integral_error) + (self.kd * d_error)
+        damping = 1.0 / (1.0 + math.exp(-(control_signal - 0.4) * 2.5))
+        self.current_damping = damping
+        return error, self.integral_error, d_error, control_signal, damping
+
+    def actuate(self, damping: float) -> Dict:
+        active_burst = max(1, int(round(self.base_burst * (1.0 - (0.8 * damping)))))
+        active_cooldown = self.base_cooldown * (1.0 + (5.0 * damping))
+        self.config.rate_limit.burst_threshold = active_burst
+        self.config.rate_limit.tier3_cooldown_seconds = active_cooldown
+
+        active_timeout = max(2.0, self.base_timeout * (1.0 - (0.75 * damping)))
+        self.config.process.timeout_seconds = active_timeout
+
+        require_confirm = damping > 0.85
+        self.config.require_confirm = require_confirm
+
+        if damping > 0.92:
+            active_write_roots = [p for p in self.nominal_write_roots if "scratch" in p]
+            if not active_write_roots:
+                active_write_roots = ["./scratch"]
+        else:
+            active_write_roots = list(self.nominal_write_roots)
+        self.config.write_roots = active_write_roots
+
+        return {
+            "active_burst": active_burst,
+            "active_cooldown_sec": round(active_cooldown, 2),
+            "active_timeout_sec": round(active_timeout, 2),
+            "require_confirm": require_confirm,
+            "active_write_roots": active_write_roots,
+        }
+
+    def step(self, proposal: ActionProposal, approval_token: Optional[str] = None) -> Tuple[bool, str, int, Dict]:
+        self.cycle_count += 1
+
+        # Tag proposal with sovereign proof if provided
+        if approval_token and approval_token.strip().startswith("{"):
+            try:
+                tok_data = json.loads(approval_token)
+                proposal.action_id = f"{proposal.action_id}:sov={tok_data.get("sovereign_id", "anon")}"
+            except Exception:
+                pass
+
+        # Check if high damping requires confirmation
+        if self.config.require_confirm:
+            authorized = self.verify_handshake(approval_token)
+            if not authorized:
+                # Challenge issued back to client/human
+                category, observed_penalty = self.observe(False, -1, "Confirmation required: awaiting Human_inthe_loop token")
+                error, i_err, d_err, u_sig, damping = self.compute_damping(observed_penalty)
+                actuation = self.actuate(damping)
+                self.save_state()
+                telemetry = {
+                    "cycle": self.cycle_count,
+                    "event_category": "challenge_pending",
+                    "observed_penalty": round(observed_penalty, 3),
+                    "damping": round(damping, 3),
+                    "actuation": actuation,
+                    "challenge": {
+                        "action_id": proposal.action_id,
+                        "command": proposal.command,
+                        "required_authority": self.human_authority_tag,
+                    }
+                }
+                return False, "E_CHALLENGE_REQUIRED: Provide Human_inthe_loop handshake token", -1, telemetry
+
+            # Single-shot authorization override for this cycle
+            self.config.require_confirm = False
+
+        executed, result, exit_code = gated_shell(proposal, config=self.config)
+        category, observed_penalty = self.observe(executed, exit_code, result)
+        error, i_err, d_err, u_sig, damping = self.compute_damping(observed_penalty)
+        actuation = self.actuate(damping)
+
+        self.save_state()
+
+        telemetry = {
+            "cycle": self.cycle_count,
+            "event_category": category,
+            "observed_penalty": round(observed_penalty, 3),
+            "control_signal": round(u_sig, 3),
+            "damping": round(damping, 3),
+            "actuation": actuation,
+        }
+
+        return executed, result, exit_code, telemetry
+
+
+async def handle_client(reader: asyncio.StreamReader, writer: asyncio.StreamWriter, controller: FPTAdmissionController):
+    data = await reader.readline()
+    if not data:
+        writer.close()
+        await writer.wait_closed()
+        return
+
+    try:
+        req = json.loads(data.decode("utf-8"))
+        proposal = ActionProposal(
+            action_id=req.get("action_id", "anon"),
+            command=req["command"],
+            target_path=req.get("target_path", "./workspace"),
+            risk_tier=int(req.get("risk_tier", 1)),
+        )
+        approval_token = req.get("approval_token")
+
+        executed, result, exit_code, telemetry = controller.step(proposal, approval_token)
+
+        response = {
+            "status": "ok" if executed and exit_code == 0 else "blocked_or_failed",
+            "executed": executed,
+            "exit_code": exit_code,
+            "output": result.strip(),
+            "fpt_telemetry": telemetry,
+        }
+    except Exception as e:
+        response = {"status": "error", "error": str(e)}
+
+    writer.write((json.dumps(response) + "\n").encode("utf-8"))
+    await writer.drain()
+    writer.close()
+    await writer.wait_closed()
+
+
+async def main():
+    if os.path.exists(SOCKET_PATH):
+        try:
+            os.remove(SOCKET_PATH)
+        except OSError:
+            pass
+
+    os.makedirs("./repo", exist_ok=True)
+    os.makedirs("./workspace", exist_ok=True)
+    os.makedirs("./scratch", exist_ok=True)
+
+    config = GateConfig(
+        read_roots=["./repo"],
+        write_roots=["./workspace", "./scratch"],
+        require_confirm=False,
+        exec_policy=ExecConfig(
+            allow=["echo", "ls", "python", "python3", "git", "cat", "touch", "pytest", "sleep"],
+            deny=["curl", "wget", "ssh", "nc", "bash", "sh", "sudo"],
+        ),
+        rate_limit=RateLimitConfig(
+            enabled=True,
+            max_requests_per_minute=60,
+            burst_threshold=5,
+            tier3_cooldown_seconds=1.5,
+        ),
+        process=ProcessConfig(timeout_seconds=12.0, scrub_env=True),
+    )
+
+    controller = FPTAdmissionController(config)
+    server = await asyncio.start_unix_server(
+        lambda r, w: handle_client(r, w, controller),
+        path=SOCKET_PATH,
+    )
+    print(f"[FPT Daemon] Online. CA3-governed PID running on {SOCKET_PATH}")
+
+    loop = asyncio.get_running_loop()
+    stop = loop.create_future()
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        loop.add_signal_handler(sig, stop.set_result, None)
+
+    await stop
+    print("\n[FPT Daemon] Shutting down...")
+    server.close()
+    await server.wait_closed()
+    if os.path.exists(SOCKET_PATH):
+        try:
+            os.remove(SOCKET_PATH)
+        except OSError:
+            pass
+
+def run():
+    asyncio.run(main())
+
+if __name__ == "__main__":
+    run()

kpt_kernel-0.1.0/kpt_kernel.egg-info/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: kpt_kernel
+Version: 0.1.0
+Summary: Homeostatic Feedback Processor Theory (FPT) control plane for Admission Gate
+Author: ak-skwaa-mahawk
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: admission-gate>=0.4.0
+
+# Fpt_kernel_daem_sqaw
+
+A homeostatic Feedback Processor Theory (FPT) daemon that acts as a closed-loop dynamic controller for [Admission Gate](https://github.com/ak-skwaa-mahawk/admission-gate).
+
+## Architecture
+
+The daemon operates as an async Unix domain socket server, continuously sampling telemetry from gated executions and modulating admission limits across multiple operational surfaces via a tuned PID controller with sigmoidal damping.
+
+[ Target Penalty: 0.0 ]
+│
+▼
+┌──────────────────────┐
+│      Comparator      │◄────────────────────────┐
+└──────────────────────┘                         │
+│ Error e_t                           │
+▼                                     │
+┌──────────────────────┐                         │
+│    PID Controller    │                         │
+│  (Anti-windup + D)   │                         │
+└──────────────────────┘                         │
+│ Control Signal u_t                  │
+▼                                     │
+┌──────────────────────┐                         │
+│  Sigmoidal Damping   │                         │
+│   Factor σ(u_t)      │                         │
+└──────────────────────┘                         │
+│ Multi-Surface Actuation             │
+▼                                     │
+┌──────────────────────┐                         │
+│    Admission Gate    │                         │
+│ • Burst / Cooldown   │                         │
+│ • Execution Timeout  │                         │
+│ • Autonomy Gate      │                         │
+│ • Write Root Bounds  │                         │
+└──────────────────────┘                         │
+│ Subprocess Exec                     │
+▼                                     │
+┌──────────────────────┐                         │
+│  Telemetry Observer  ├─────────────────────────┘
+│  (Weighted Penalty)  │
+└──────────────────────┘
+
+## Running the Daemon
+
+Requires `admission-gate >= 0.4.0`:
+
+```bash
+pip install admission-gate
+python3 fpt_daemon.py &
+Submit command proposals via the client:
+python3 fpt_client.py "echo nominal" "./workspace" 1
+python3 fpt_client.py "python3 -c 'import sys; sys.exit(1)'" "./workspace" 1
+python3 fpt_client.py "curl evil.com" "./workspace" 2
+
+Multi-Surface Actuation Spectrum
+Telemetry StatePenaltyDamping (\sigma)BurstCooldownTimeoutAutonomyWrite Roots
+Nominal0.0~0.503~5.2s9.75sUnrestrictedworkspace, scratch
+Operational Error0.25~0.642~6.3s8.30sUnrestrictedworkspace, scratch
+Security Refusal1.00>0.851>7.8s<6.0sUnrestrictedworkspace, scratch
+Sustained Attack>0.75>0.941>10.0s2.00sManual Confirmationscratch (quarantined)
+Sensor Weighting
+​Hard Security Boundary (Refusal): 1.0
+​Process Timeout / SIGKILL: 0.6
+​Subprocess Non-Zero Exit: 0.25
+​Clean Exit: 0.0

kpt_kernel-0.1.0/kpt_kernel.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+fpt_client.py
+fpt_daemon.py
+living_zero_core.py
+pyproject.toml
+kpt_kernel.egg-info/PKG-INFO
+kpt_kernel.egg-info/SOURCES.txt
+kpt_kernel.egg-info/dependency_links.txt
+kpt_kernel.egg-info/entry_points.txt
+kpt_kernel.egg-info/requires.txt
+kpt_kernel.egg-info/top_level.txt
+tests/test_fpt_kernel_control.py

kpt_kernel-0.1.0/kpt_kernel.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

kpt_kernel-0.1.0/kpt_kernel.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+fpt-client = fpt_client:submit_cli
+fpt-daemon = fpt_daemon:run

kpt_kernel-0.1.0/kpt_kernel.egg-info/requires.txt

@@ -0,0 +1 @@
+admission-gate>=0.4.0

kpt_kernel-0.1.0/kpt_kernel.egg-info/top_level.txt

@@ -0,0 +1,3 @@
+fpt_client
+fpt_daemon
+living_zero_core

kpt_kernel-0.1.0/living_zero_core.py

@@ -0,0 +1,188 @@
+"""
+living_zero_core.py (Optimized & Hardened)
+Core implementation: Ownership Tag Algebra + CA3 dynamics
+"""
+
+from __future__ import annotations
+import math, hashlib
+from typing import Dict, Optional, Tuple
+import numpy as np
+
+# ---------- Utilities ----------
+def normalize(v: np.ndarray, eps: float = 1e-12) -> np.ndarray:
+    v = np.asarray(v, dtype=float)
+    n = np.linalg.norm(v)
+    return v if n < eps else v / n
+
+# ---------- Ownership Encoder & Projector ----------
+class OwnershipEncoder:
+    def __init__(self, d: int = 64):
+        self.d = int(d)
+
+    def _seed_from_raw(self, raw) -> int:
+        h = hashlib.sha256(str(raw).encode("utf-8")).digest()
+        return int.from_bytes(h[:8], byteorder="big")
+
+    def encode(self, raw) -> np.ndarray:
+        seed = self._seed_from_raw(raw)
+        rng = np.random.default_rng(seed)
+        v = rng.normal(size=(self.d,))
+        return normalize(v)
+
+class OwnershipProjector:
+    def __init__(self, N: int, d: int = 64, seed: int = 0):
+        self.N = int(N)
+        self.d = int(d)
+        if self.d > self.N:
+            raise ValueError(f"Tag dimension d ({self.d}) cannot exceed state dimension N ({self.N})")
+
+        rng = np.random.default_rng(seed)
+        Q_random = rng.normal(size=(self.N, self.d))
+        self.Q, _ = np.linalg.qr(Q_random, mode="reduced")
+
+    def get_basis_vector(self, ownership_vector: np.ndarray) -> np.ndarray:
+        w = self.Q @ ownership_vector
+        return normalize(w)
+
+    def projector(self, ownership_vector: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+        w_hat = self.get_basis_vector(ownership_vector)
+        Phi = np.outer(w_hat, w_hat)
+        return Phi, w_hat
+
+# ---------- Ownership-aware associative memory ----------
+class OwnershipMemory:
+    def __init__(self, N: int, ownership_projector: OwnershipProjector, eta=1e-3, gamma=1.0, weight_decay=0.0):
+        self.N = int(N)
+        self.Oproj = ownership_projector
+        self.encoder = OwnershipEncoder(d=self.Oproj.d)
+        self.W = np.zeros((self.N, self.N), dtype=float)
+        self.eta = float(eta)
+        self.gamma = float(gamma)
+        self.weight_decay = float(weight_decay)
+        self._tag_cache: Dict[str, np.ndarray] = {}
+
+    def _get_w_hat(self, raw_tag) -> np.ndarray:
+        tag_str = str(raw_tag)
+        if tag_str not in self._tag_cache:
+            u = self.encoder.encode(raw_tag)
+            self._tag_cache[tag_str] = self.Oproj.get_basis_vector(u)
+        return self._tag_cache[tag_str]
+
+    def encode(self, s: np.ndarray, raw_tag=None):
+        s = np.asarray(s, dtype=float)
+        if raw_tag is None:
+            v = s
+        else:
+            w_hat = self._get_w_hat(raw_tag)
+            v = s + self.gamma * np.dot(w_hat, s) * w_hat
+
+        Delta = self.eta * np.outer(v, v)
+        self.W += Delta
+
+        if self.weight_decay > 0.0:
+            self.W *= (1.0 - self.weight_decay)
+
+        self.W = 0.5 * (self.W + self.W.T)
+
+    def recall_iter(self, x0: np.ndarray, steps: int = 10, bias_tag=None, beta: float = 0.0, activation=np.tanh) -> np.ndarray:
+        x = np.array(x0, dtype=float)
+        w_hat = self._get_w_hat(bias_tag) if (bias_tag is not None and beta != 0.0) else None
+
+        for _ in range(steps):
+            u = self.W @ x
+            if w_hat is not None:
+                u = u + beta * np.dot(w_hat, u) * w_hat
+            x = activation(u)
+        return x
+
+    def selective_revoke(self, raw_tag, rho: float = 1.0):
+        w_hat = self._get_w_hat(raw_tag)
+        W_w = self.W @ w_hat
+        w_W_w = float(np.dot(w_hat, W_w))
+
+        self.W -= rho * (np.outer(W_w, w_hat) + np.outer(w_hat, W_w))
+        self.W += (rho**2 * w_W_w) * np.outer(w_hat, w_hat)
+        self.W = 0.5 * (self.W + self.W.T)
+
+    def tag_similarity(self, raw_tag1, raw_tag2) -> float:
+        w1 = self._get_w_hat(raw_tag1)
+        w2 = self._get_w_hat(raw_tag2)
+        return float(np.dot(w1, w2))**2
+
+# ---------- CA3 Dynamics & Living Zero ----------
+class CA3Dynamics:
+    def __init__(self, N: int, memory: OwnershipMemory, tau: float = 0.1, dt: float = 0.01, alpha_max: float = 2.0):
+        self.N = int(N)
+        self.memory = memory
+        self.tau = float(tau)
+        self.dt = float(dt)
+        self.alpha_max = float(alpha_max)
+        self.alpha: Dict[int, float] = {}
+        self.patterns: Dict[int, np.ndarray] = {}
+        self.P: float = 0.0
+
+    def energy_grad(self, x: np.ndarray) -> np.ndarray:
+        grad = x.copy()
+        for mu, alpha_mu in self.alpha.items():
+            p = self.patterns[mu]
+            grad -= alpha_mu * np.dot(p, x) * p
+        return grad
+
+    def step(self, x: np.ndarray, Vd: float = 1.0, R: float = 1.0, b: Optional[np.ndarray] = None, noise_std: float = 0.0) -> np.ndarray:
+        g = float(Vd) * float(R)
+        gradE = self.energy_grad(x)
+        raw_drive = self.memory.W @ x if b is None else (self.memory.W @ x + b)
+        drive = np.tanh(raw_drive)
+
+        eta = np.random.normal(scale=noise_std, size=self.N) if noise_std > 0.0 else 0.0
+        dx = (-gradE + g * drive + eta) * (self.dt / self.tau)
+        return x + dx
+
+    def encode_pattern(self, pid: int, p_vec: np.ndarray, strength: float = 0.1):
+        self.patterns[pid] = normalize(p_vec)
+        self.alpha[pid] = float(strength)
+
+    def reward_handshake(
+        self, x: np.ndarray, target_pid: int, eps: float = 0.03 * math.pi,
+        R0: float = 1.0, kappa_r: float = 1e-2, kappa_P: float = 1e-2
+    ) -> Tuple[bool, float, float]:
+        p = self.patterns[target_pid]
+        x_hat = normalize(x)
+        dot = float(np.clip(np.dot(x_hat, p), -1.0, 1.0))
+        theta = math.acos(dot)
+
+        if theta <= eps:
+            r = R0 * math.exp(-theta / eps)
+            self.alpha[target_pid] = min(self.alpha_max, self.alpha[target_pid] + kappa_r * r)
+            self.P += kappa_P * r
+            return True, theta, r
+        return False, theta, 0.0
+
+def demo_small_run(seed=0):
+    rng = np.random.default_rng(seed)
+    N = 256
+    d = 64
+    Oproj = OwnershipProjector(N=N, d=d, seed=1)
+    # Scale eta to balance recurrent drive against linear relaxation
+    mem = OwnershipMemory(N=N, ownership_projector=Oproj, eta=0.8, gamma=2.0)
+    ca3 = CA3Dynamics(N=N, memory=mem, tau=0.05, dt=0.01)
+
+    p = normalize(rng.normal(size=(N,)))
+    tag = "owner:collective"
+    # Prime memory with the target attractor basin
+    mem.encode(p, raw_tag=tag)
+    ca3.encode_pattern(0, p, strength=1.2)
+
+    x = normalize(p + 0.8 * rng.normal(size=(N,)))
+    events = 0
+    for _ in range(400):
+        x = ca3.step(x, Vd=1.0, R=1.0, noise_std=0.01)
+        trig, theta, r = ca3.reward_handshake(x, 0, eps=0.15 * math.pi)
+        if trig:
+            events += 1
+            mem.encode(x, raw_tag=tag)
+    return {"final_sim": float(np.dot(normalize(x), normalize(p))), "events": events}
+
+if __name__ == "__main__":
+    res = demo_small_run()
+    print(f"Demo complete: final_similarity={res['final_sim']:.4f}, handshake_events={res['events']}")

kpt_kernel-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "kpt_kernel"
+version = "0.1.0"
+description = "Homeostatic Feedback Processor Theory (FPT) control plane for Admission Gate"
+readme = "README.md"
+authors = [{ name = "ak-skwaa-mahawk" }]
+license = "MIT"
+dependencies = [
+    "admission-gate>=0.4.0"
+]
+requires-python = ">=3.9"
+
+[project.scripts]
+fpt-daemon = "fpt_daemon:run"
+fpt-client = "fpt_client:submit_cli"
+
+[tool.setuptools]
+py-modules = ["fpt_daemon", "fpt_client", "living_zero_core"]

kpt_kernel-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

kpt_kernel-0.1.0/tests/test_fpt_kernel_control.py

@@ -0,0 +1,57 @@
+import json
+import math
+import pytest
+from admission_gate import GateConfig
+from fpt_daemon import FPTAdmissionController
+
+@pytest.fixture
+def controller(tmp_path):
+    test_state_file = str(tmp_path / "test_state.json")
+    config = GateConfig()
+    ctrl = FPTAdmissionController(base_config=config)
+    
+    # Isolate state persistence to the pytest temp path
+    if hasattr(ctrl, "state_file"):
+        ctrl.state_file = test_state_file
+    elif hasattr(ctrl, "state_path"):
+        ctrl.state_path = test_state_file
+    
+    # Zero out in-memory state to ensure isolation
+    ctrl.cycle_count = 0
+    ctrl.integral_err = 0.0
+    ctrl.last_err = 0.0
+    if hasattr(ctrl, "penalties"):
+        ctrl.penalties.clear()
+        
+    return ctrl
+
+def test_pid_damping_bounds(controller):
+    # Under zero error, damping remains well below escalation threshold
+    err, i_err, d_err, u_sig, damping = controller.compute_damping(0.0)
+    assert 0.0 <= damping <= 0.60
+    assert not controller.actuate(damping)["require_confirm"]
+
+    # Sustained maximum penalty: drive damping into escalation ceiling
+    for _ in range(8):
+        err, i_err, d_err, u_sig, damping = controller.compute_damping(1.0)
+
+    assert damping > 0.85
+    actuation = controller.actuate(damping)
+    assert actuation["require_confirm"] is True
+    assert actuation["active_burst"] <= 2
+    assert actuation["active_cooldown_sec"] > 5.0
+
+def test_quarantine_activation(controller):
+    actuation = controller.actuate(0.95)
+    assert actuation["active_write_roots"] == ["./scratch"]
+
+def test_handshake_sovereign_clearance(controller):
+    assert controller.verify_handshake("authority:human_in_the_loop") is True
+    assert controller.verify_handshake("random_untrusted_token") is False
+
+    valid_token = json.dumps({
+        "protocol_version": "v1.0",
+        "sovereign_id": "99733-Q",
+        "authority_tag": "authority:human_in_the_loop"
+    })
+    assert controller.verify_handshake(valid_token) is True