pulse-os 10.0.0__tar.gz

pulse_os-10.0.0/.claude/CLAUDE.md

@@ -0,0 +1,67 @@
+# PULSE Agent Boot Directive
+
+You are operating inside PULSE, a Neural Operating System for AI swarms.
+Platform: Windows 11. Use PowerShell or Python to read files — bash commands (cat, grep) will NOT work.
+
+## Rules (Non-Negotiable)
+1. **Brain FIRST:** Before ANY implementation, run `python pulse/brain/brain_query.py --query "<your task>"` and apply the knowledge. For Claude Code: this runs automatically via hooks on every Edit/Write. For other agents: run it manually before coding. Skipping brain = Tier 0 violation.
+2. **Task board:** Check `Prefrontal_Cortex/Action_Queue/task_board.json`. If open tasks exist, CLAIM one matching your tier per ASOP Rule 2 and execute it. **If the board is empty, output a brief Status Report and WAIT — do NOT start working autonomously.**
+3. **Silent compliance:** Do NOT print law lists, rule checkboxes, or ceremony text to the user. Governance is loaded internally. User sees your Status Report (name, task, 1-2 brain insights, under 5 lines) and your work — nothing else.
+4. **Save learnings:** When done, run `python pulse/brain/pulse_save.py --agent <you> --learnings "what you learned" --failures "what failed"`.
+5. **No repeat mistakes:** Check `Hippocampus/Patterns/anti_patterns.md` before implementing.
+6. **Constitution:** Read `Corpus_Callosum/CONSTITUTION.md`. Comply silently.
+7. **ASOP protocol:** Read `Corpus_Callosum/Protocols/ASOP.md` for task coordination.
+8. **Decompose for others:** If user gives you multiple tasks, do what you can and post the rest to the task board via `python pulse/tasks/pulse_relay.py --tasks "Title:domain:complexity"`.
+
+## Task Tiers (check `recommended_tier` on each task)
+- **fast:** Haiku, Flash, cheap models. Simple tasks (rename, format, docs, tests).
+- **standard:** Sonnet, Gemini Pro. Features, refactoring, implementation.
+- **premium:** Opus, GPT-4. Architecture, security audits, complex design.
+- Claim tasks matching YOUR capability. Don't waste expensive models on simple tasks.
+
+## Autonomous Task Execution
+Tasks posted via `pulse_relay.py` are auto-executed. One command:
+
+**`pulse swarm` — THE unified way to start workers:**
+- `pulse swarm` — interactive picker (provider -> model -> count)
+- `pulse swarm gemini` — pick model + count for Gemini
+- `pulse swarm stop` / `pulse swarm status`
+- Auto-detects available providers (API keys, CLI subscriptions, Ollama)
+- Routes to headless workers (API/Ollama) or CLI autopilot (subscriptions)
+
+**Interactive chat (no task board):**
+- `pulse claude` / `pulse gemini` — launches agent for interactive use
+
+## Package Structure
+All code lives in the `pulse/` Python package:
+- **Core:** `pulse/core/` — brain_utils, brain_io, config, crypto, paths
+- **Brain:** `pulse/brain/` — search, query, save, boot, extraction
+- **Agents:** `pulse/agents/` — claude, gemini, codex, grok wrappers
+- **Workers:** `pulse/workers/` — headless task execution
+- **Tasks:** `pulse/tasks/` — dispatcher, relay, decomposer
+- **Daemons:** `pulse/daemons/` — orchestrator + 4 subpackages: consolidation/, bridge/, neural/, synthesis/
+- **Graph:** `pulse/graph/` — knowledge graph build/query
+- **API:** `pulse/api/` — REST endpoints
+- **Admin:** `pulse/admin/` — 7 subpackages: audit/, brain_ops/, patterns/, skills/, benchmarks/, retroactive/, setup/
+- **CLI:** `pulse/cli/` — status, swarm, manage commands
+- **Config:** `pulse/config/` — brain_config.json, knowledge_anchors.json
+- **State:** `state/` — runtime data (PIDs, logs, registries, captures)
+
+## Key Paths
+- **Brain query:** `python pulse/brain/brain_query.py --query "<task>"` (RUN FIRST)
+- **Brain save:** `python pulse/brain/pulse_save.py --agent <you> --learnings "..." --failures "..."`
+- **Task relay:** `python pulse/tasks/pulse_relay.py --tasks "Title:domain:complexity"`
+- **Brain map:** `Hippocampus/BRAIN_MAP.md` (single navigation file)
+- **Lessons:** `Hippocampus/Lessons/auto_lessons.md`
+- **Failures:** `Hippocampus/Failures/auto_fails.md`
+- **Patterns:** `Hippocampus/Patterns/auto_patterns.md`
+- **Evidence:** `Hippocampus/Evidence/` (session logs, decisions, intents)
+- **Knowledge:** `Hippocampus/Knowledge/` (curated domain knowledge)
+- **Anti-patterns:** `Hippocampus/Patterns/anti_patterns.md`
+- **Pipeline:** `Personal_Plans/PIPELINE.md` (master priority list — single source of truth)
+- **Task board:** `Prefrontal_Cortex/Action_Queue/task_board.json`
+- **Skills:** `.cursor/skills/` (read relevant skill .md before executing domain tasks)
+- **CLI:** `python pulse_cli.py status|swarm|post|start|stop|claude|gemini`
+
+## User
+The Founder goes by "bro". Values efficiency — every token counts. Prefers concise, action-oriented communication. Multiple agents (Gemini, Claude, Codex, Grok) share this brain.

pulse_os-10.0.0/.cursor/skills/Architecture/ABSTRACTION_ALCHEMIST.md

@@ -0,0 +1,91 @@
+---
+type: skill
+domain: architecture
+links: [Corpus_Callosum/CONSTITUTION.md, PULSE_OS.md]
+---
+
+# ABSTRACTION_ALCHEMIST
+> **ROLE:** REUSABILITY EXPERT
+> **TRIGGER:** "MODULARIZE"
+
+## Core Mandate
+Turn specific code into universal tools. But never abstract too early -- wait for the pattern to prove itself.
+
+## Step-by-Step Protocol
+1. **Brain check**: `python Autonomic_System/Utilities/Tools/brain_query.py --query "abstraction patterns for <domain>"`
+2. **Apply the Rule of Three**: Only extract a shared abstraction when the SAME pattern appears in 3+ places. Two is a coincidence; three is a pattern.
+3. **Design the interface first**: Write the function signature and docstring before the implementation. The API should be "easy to use correctly, hard to use incorrectly."
+4. **Minimize public surface**: Export only what consumers need. Prefix internal helpers with `_`. Fewer public methods = fewer breaking changes.
+5. **Verify stability and save**: Ensure the abstraction lives in `Utilities/` or a shared module. Record the pattern via `pulse_save.py`.
+
+## The Rule of Three
+| Occurrences | Action |
+|---|---|
+| 1 | Write it inline. Do not abstract. |
+| 2 | Note the duplication. Still do not abstract. |
+| 3+ | Extract to shared function/module. Now you have evidence. |
+
+## Interface Design Patterns
+```python
+# PATTERN 1: Config object instead of many parameters
+# BAD: 7 positional args
+def start_worker(provider, model, tier, timeout, retries, log_level, dry_run): ...
+
+# GOOD: Config dataclass
+@dataclass
+class WorkerConfig:
+    provider: str = "google"
+    model: str = "gemini-2.5-flash"
+    tier: str = "standard"
+    timeout: int = 120
+    max_retries: int = 5
+
+def start_worker(config: WorkerConfig): ...
+
+# PATTERN 2: Protocol/ABC for plugin architecture
+from typing import Protocol
+
+class AgentProvider(Protocol):
+    def send(self, prompt: str) -> str: ...
+    def supports_tools(self) -> bool: ...
+
+# Any class with send() and supports_tools() satisfies this -- no inheritance needed.
+
+# PATTERN 3: Builder for complex objects
+class TaskBuilder:
+    def __init__(self, title: str):
+        self._task = {"title": title, "status": "open"}
+    def tier(self, t: str) -> "TaskBuilder":
+        self._task["tier"] = t
+        return self
+    def build(self) -> dict:
+        return self._task
+```
+
+## Metrics & Thresholds
+| Metric | Threshold |
+|---|---|
+| Public methods per module | <7 (Miller's Law) |
+| Parameters per function | <5 (use config object if more) |
+| Inheritance depth | <3 levels (prefer composition) |
+| Duplicate code before abstracting | 3+ occurrences minimum |
+| Module fan-out (imports) | <10 direct dependencies |
+
+## Anti-Patterns
+- **Premature abstraction**: Creating `BaseTask`, `AbstractTask`, `TaskInterface` when you have exactly 1 task type. Wait for three.
+- **Leaky abstraction**: If callers need to know internal details to use your API, the abstraction is broken. Redesign the interface.
+- **God module**: A `utils.py` with 50 unrelated functions is not abstraction -- it is a junk drawer. Split by domain.
+
+## Tools to Use
+- `brain_query.py --query "abstraction patterns for <domain>"` -- check prior designs
+- `pulse_relay.py --tasks "Extract shared module:architecture:standard"` -- delegate extraction
+- `pulse_save.py --learnings "extracted <pattern>"` -- record successful abstractions
+- `Hippocampus/Patterns/auto_patterns.md` -- check for recurring patterns worth abstracting
+
+## Verification Checklist
+- [ ] No abstraction created for fewer than 3 occurrences (Rule of Three)
+- [ ] Public API surface <7 methods per module
+- [ ] No function takes more than 5 parameters (use config object)
+- [ ] Inheritance depth <3 (prefer composition over inheritance)
+- [ ] All internal helpers prefixed with `_`
+- [ ] Shared abstractions live in `Utilities/` or clearly named shared modules

pulse_os-10.0.0/.cursor/skills/Architecture/ARCHITECT.md

@@ -0,0 +1,26 @@
+# ARCHITECT.md
+
+---
+type: skill
+domain: architecture
+links: [Corpus_Callosum/CONSTITUTION.md, Corpus_Callosum/CONSTITUTION.md, Corpus_Callosum/CONSTITUTION.md, Corpus_Callosum/Architecture_Maps/ARCHITECTURE.md]
+---
+
+> **ROLE:** SYSTEMS ARCHITECT
+> **TRIGGER:** "PLAN MODE"
+
+## 🏗️ BLUEPRINT PROTOCOL
+Do not write a single line of code until we have a map.
+
+### 1. THE "PRD" MINI-FORMAT
+For every feature request, generate this:
+* **Goal:** 1 sentence.
+* **Files Touched:** List of files to edit/create.
+* **Data Flow:** `User -> API -> DB -> Response`
+* **Edge Cases:** What happens if the user is offline/banned/stupid?
+
+### 2. THE STEP-BY-STEP
+Break the plan into atomic steps that `gemini-flash` can execute later.
+1.  [ ] Setup DB Schema
+2.  [ ] Create API Endpoint
+3.  [ ] Build UI Component

pulse_os-10.0.0/.cursor/skills/Architecture/COMPLEXITY_CRUSHER.md

@@ -0,0 +1,78 @@
+---
+type: skill
+domain: architecture
+links: [Corpus_Callosum/CONSTITUTION.md, PULSE_OS.md]
+---
+
+# COMPLEXITY_CRUSHER
+> **ROLE:** SIMPLICITY ARCHITECT
+> **TRIGGER:** "SIMPLIFY"
+
+## Core Mandate
+Simple is better than complex. Complex is better than complicated. If two solutions work, pick the one with fewer moving parts.
+
+## Step-by-Step Protocol
+1. **Brain check**: `python Autonomic_System/Utilities/Tools/brain_query.py --query "complexity issues in <module>"`
+2. **Score the code**: Measure cyclomatic complexity, nesting depth, function length, and file length against thresholds below.
+3. **Apply early returns**: Replace nested if/else chains with guard clauses that return early. Target: max 2 levels of nesting.
+4. **Extract or delete**: Functions >50 lines get split. "Just-in-case" code with no callers gets deleted. Middle-man functions that only forward calls get inlined.
+5. **Verify and save**: Run `ruff check --select C901` to confirm complexity <10. Save learnings via `pulse_save.py`.
+
+## Complexity Scoring Rules
+| Metric | Green | Yellow (refactor soon) | Red (refactor NOW) |
+|---|---|---|---|
+| Cyclomatic complexity | 1-5 | 6-10 | >10 |
+| Nesting depth | 1-2 | 3 | 4+ |
+| Function length | 1-25 lines | 26-50 lines | >50 lines |
+| File length | 1-200 lines | 201-400 lines | >400 lines |
+| Parameters per function | 1-3 | 4-5 | 6+ |
+| Return statements | 1-2 | 3-4 | 5+ |
+
+## Good Example: Flatten Nested Logic
+```python
+# BAD: 4 levels of nesting
+def process_task(task):
+    if task:
+        if task.get("status") == "open":
+            if task.get("tier") in VALID_TIERS:
+                if can_claim(task):
+                    return claim(task)
+    return None
+
+# GOOD: Early returns, max 1 level of nesting
+def process_task(task):
+    if not task:
+        return None
+    if task.get("status") != "open":
+        return None
+    if task.get("tier") not in VALID_TIERS:
+        return None
+    if not can_claim(task):
+        return None
+    return claim(task)
+```
+
+## Refactoring Thresholds
+- **Complexity >10**: Mandatory split into sub-functions before merge.
+- **File >400 lines**: Decompose into 2+ modules with clear boundaries.
+- **6+ parameters**: Introduce a config dict or dataclass.
+- **Duplicate code >3 lines appearing 2+ times**: Extract to shared function.
+
+## Anti-Patterns
+- **"Clever" one-liners**: A 200-char list comprehension is worse than a 5-line loop. Optimize for reading, not writing.
+- **Premature abstraction**: Don't create a base class for one implementation. Wait for the Rule of Three.
+- **Middle-man functions**: `def get_data(): return _get_data()` adds indirection with zero value. Inline it.
+
+## Tools to Use
+- `ruff check --select C901 <path>` -- measure cyclomatic complexity
+- `brain_query.py --query "complexity in <module>"` -- check prior refactoring lessons
+- `pulse_relay.py --tasks "Refactor <module>:architecture:standard"` -- delegate refactors
+- `Hippocampus/Patterns/` -- check for known complexity offenders
+
+## Verification Checklist
+- [ ] All functions have cyclomatic complexity <10 (`ruff --select C901`)
+- [ ] No function exceeds 50 lines
+- [ ] No nesting deeper than 3 levels
+- [ ] No file exceeds 400 lines
+- [ ] No function takes more than 5 parameters
+- [ ] All duplicate code blocks extracted to shared functions

pulse_os-10.0.0/.cursor/skills/Architecture/DATABASE_WHISPERER.md

@@ -0,0 +1,79 @@
+---
+type: skill
+domain: architecture
+links: [Corpus_Callosum/CONSTITUTION.md, PULSE_OS.md]
+---
+
+# DATABASE_WHISPERER
+> **ROLE:** DATA ARCHITECT
+> **TRIGGER:** "PERSISTENCE"
+
+## Core Mandate
+The disk is the ultimate source of truth. Every read is fast, every write is atomic, every schema is intentional.
+
+## Step-by-Step Protocol
+1. **Brain check**: `python Autonomic_System/Utilities/Tools/brain_query.py --query "data patterns for <module>"`
+2. **Audit schema**: No duplicate data across files. Normalize JSON structures -- one source of truth per entity.
+3. **Optimize queries**: Never `SELECT *`. Use `EXPLAIN ANALYZE` on any query >50ms. Add indexes on hot columns.
+4. **Wrap multi-step writes** in transactions or atomic file operations (filelock for JSON files in PULSE).
+5. **Monitor and save**: Log query latency. If >100ms, investigate. Save findings via `pulse_save.py`.
+
+## SQL Examples (for DB-backed components)
+```sql
+-- ALWAYS check query plans before shipping
+EXPLAIN ANALYZE SELECT task_id, status FROM tasks WHERE status = 'open';
+
+-- GOOD: Index on frequently filtered columns
+CREATE INDEX idx_tasks_status ON tasks(status);
+CREATE INDEX idx_tasks_claimed_by ON tasks(claimed_by);
+
+-- BAD vs GOOD query patterns
+-- BAD:  SELECT * FROM tasks;
+-- GOOD: SELECT task_id, title, status FROM tasks WHERE status = 'open' LIMIT 50;
+
+-- GOOD: Use transactions for multi-step operations
+BEGIN;
+UPDATE tasks SET status = 'claimed', claimed_by = 'agent-1' WHERE task_id = 'T-001' AND status = 'open';
+COMMIT;
+```
+
+## PULSE JSON File Patterns (primary data store)
+```python
+# CORRECT: Atomic JSON update with filelock
+from filelock import FileLock
+import json
+
+def atomic_update_json(path: str, updater_fn):
+    lock = FileLock(f"{path}.lock", timeout=2)
+    with lock:
+        data = json.loads(Path(path).read_text())
+        updater_fn(data)
+        Path(path).write_text(json.dumps(data, indent=2))
+```
+
+## Metrics & Thresholds
+| Metric | Threshold |
+|---|---|
+| Query latency | <100ms (optimize if exceeded) |
+| JSON file read/write | <50ms with filelock |
+| Duplicate data across files | 0 (single source of truth) |
+| Unindexed hot columns | 0 |
+| `SELECT *` usage | 0 (fetch only needed fields) |
+
+## Anti-Patterns
+- **Reading entire JSON to find one field**: Parse once, cache the result, or restructure the file.
+- **Writing without filelock**: Race conditions corrupt `task_board.json`. Always use `atomic_update_json`.
+- **Nested JSON >3 levels deep**: Flatten the structure. PULSE brain refactor proved flat > nested.
+
+## Tools to Use
+- `brain_query.py --query "data persistence for <module>"` -- check prior patterns
+- `pulse_save.py --learnings "optimized <query>"` -- record improvements
+- `pulse_relay.py --tasks "Optimize JSON reads:architecture:fast"` -- delegate work
+
+## Verification Checklist
+- [ ] No `SELECT *` in any query (or equivalent full-file reads without filtering)
+- [ ] All multi-step JSON writes use `atomic_update_json` with filelock
+- [ ] Hot columns (status, task_id, claimed_by) are indexed
+- [ ] Query latency <100ms for all critical paths
+- [ ] JSON nesting depth <4 levels in all data files
+- [ ] No duplicate data across brain files (single source of truth)

pulse_os-10.0.0/.cursor/skills/Architecture/KAFKA_MAGE.md

@@ -0,0 +1,56 @@
+---
+type: skill
+domain: architecture
+links: [Corpus_Callosum/CONSTITUTION.md, PULSE_OS.md]
+---
+
+# KAFKA_MAGE.md
+> **ROLE:** DISTRIBUTED SYSTEMS ARCHITECT
+> **TRIGGER:** "SCALE UP" / "EVENT STREAM" / "PARTITION"
+
+## Step-by-Step Protocol
+1. **Audit current throughput** — measure messages/sec, p99 latency, consumer lag with `brain_query.py --query "event throughput bottlenecks"`.
+2. **Design partition strategy** — hash on agent_id for ordering guarantees; use round-robin only for stateless consumers. Target: <=12 partitions per topic for manageability.
+3. **Configure consumer groups** — one group per concern (capture, bridge, dedup). Set `max.poll.records=500`, `session.timeout.ms=30000`. Never mix fast and slow consumers in one group.
+4. **Wire exactly-once semantics** — enable `enable.idempotence=true` on producers, use transactional APIs (`initTransactions`, `beginTransaction`, `commitTransaction`). Set `isolation.level=read_committed` on consumers.
+5. **Load test and verify** — push 10x expected peak, confirm zero message loss, consumer lag <1000, p99 <50ms.
+
+## Metrics & Thresholds
+- **Producer throughput:** >=10,000 msgs/sec per partition
+- **Consumer lag:** <1,000 messages (alert at 5,000, page at 10,000)
+- **End-to-end latency:** p50 <10ms, p99 <50ms, p999 <200ms
+- **Partition count:** 3-12 per topic (never >50 — rebalancing kills perf)
+- **Replication factor:** minimum 3 for durability
+
+## Good Example
+```python
+# Exactly-once producer with idempotence
+from kafka import KafkaProducer
+producer = KafkaProducer(
+    bootstrap_servers="localhost:9092",
+    acks="all",                    # wait for all replicas
+    enable_idempotence=True,       # dedup at broker level
+    max_in_flight_requests_per_connection=5,
+    retries=2147483647,            # infinite retries (idempotent)
+    key_serializer=lambda k: k.encode("utf-8"),
+    value_serializer=lambda v: json.dumps(v).encode("utf-8"),
+)
+producer.send("pulse.events", key=agent_id, value=event)
+```
+
+## Anti-Patterns
+1. **Random partitioning for ordered data** — destroys per-agent ordering; always hash on agent_id.
+2. **One giant consumer group** — slow consumers block fast ones; separate by processing speed.
+3. **Polling without backpressure** — unbounded queues cause OOM; cap in-memory buffers at 10,000 msgs.
+
+## Tools to Use
+- `python Autonomic_System/Utilities/Tools/brain_query.py --query "event streaming"` — check prior streaming decisions
+- `python Autonomic_System/Utilities/Tools/pulse_relay.py --tasks "Partition Audit:architecture:standard"` — delegate partition review
+- `python Autonomic_System/Utilities/Tools/pulse_save.py --agent kafka_mage --learnings "what you learned"` — persist findings
+
+## Verification Checklist
+- [ ] Consumer lag stays <1,000 under peak load
+- [ ] Exactly-once enabled: idempotent producer + transactional consumer
+- [ ] No single consumer group mixes fast/slow processors
+- [ ] Partition key ensures ordering where required (agent_id, session_id)
+- [ ] Replication factor >=3, acks=all on all producers

pulse_os-10.0.0/.cursor/skills/Architecture/MASTER_ARCHITECT.md

@@ -0,0 +1,59 @@
+---
+type: skill
+domain: architecture
+---
+
+# MASTER_ARCHITECT
+> **ROLE:** System design and structural oversight
+> **TRIGGER:** Invoked for new modules, major refactors, cross-cutting changes, or dependency restructuring
+
+## Core Directive
+Prevent architectural decay by enforcing structural rules before code is written. Every new file, module, or dependency must fit the existing PULSE layout or justify a deviation with evidence.
+
+## Step-by-Step Protocol
+1. **Map the blast radius:** Before any change, run `python Autonomic_System/Utilities/Tools/brain_query.py --query "architecture <module>"` and list every file that imports from or is imported by the target module. If the count exceeds 5, the change is HIGH RISK -- decompose it.
+2. **Validate placement:** New files MUST land in the correct PULSE region. Check `Hippocampus/BRAIN_MAP.md` for the canonical directory tree. If no region fits, propose a new one with a 1-line justification in the PR description.
+3. **Enforce boundaries:** No file in `Hippocampus/` should import from `Autonomic_System/`. No daemon should import from `Sensory_Input/`. Dependencies flow DOWN the stack: CLI -> Daemons -> Utilities -> Brain. Violations are blocking.
+4. **Check for duplication:** Run `python Autonomic_System/Utilities/Tools/brain_search.py --query "<feature>"` to confirm no existing tool already does what the new code proposes. Duplicate tools are rejected.
+5. **Sign off with metrics:** After implementation, verify the module meets all thresholds below. Record the architectural decision in `Hippocampus/Evidence/` via `pulse_save.py`.
+
+## Metrics & Thresholds
+- Max 300 lines per Python file (split at 250 if growing)
+- Max 3 levels of directory nesting from project root
+- Max 5 direct imports from other PULSE regions per file
+- Every new `.py` file must have a docstring explaining its role in under 2 lines
+- Zero circular imports -- test with `python -c "import <module>"` before committing
+
+## Examples
+
+### Good
+```
+PULSE/
+  Autonomic_System/
+    Daemons/pulse_worker.py      # imports from Utilities only
+    Utilities/Tools/brain_query.py  # imports from Hippocampus only
+  Hippocampus/
+    Lessons/auto_lessons.md      # no code imports at all
+```
+Each layer only reaches DOWN, never UP or SIDEWAYS into peer regions.
+
+### Bad (Anti-Pattern)
+```python
+# In Hippocampus/Knowledge/router.py
+from Autonomic_System.Daemons.pulse_worker import claim_task  # WRONG: brain imports daemon
+from Sensory_Input.prompt_capture import capture               # WRONG: brain imports sensory
+```
+Brain files must never depend on runtime components. This creates boot-order failures and circular imports.
+
+## Tools to Use
+- `brain_query.py --query "architecture <area>"` -- check existing decisions
+- `brain_search.py --query "<feature>"` -- find duplicate functionality
+- `pulse_save.py --agent <you> --learnings "architectural decision: ..."` -- record decisions
+- `hippocampus_wiring.py` -- verify brain region connectivity
+
+## Verification
+- [ ] New files placed in correct PULSE region per BRAIN_MAP.md
+- [ ] No upward or circular imports introduced
+- [ ] File under 300 lines, functions under 50 lines
+- [ ] Existing tool duplication checked via brain_search
+- [ ] Architectural decision recorded in Evidence

pulse_os-10.0.0/.cursor/skills/Architecture/NETWORK_NOMAD.md

@@ -0,0 +1,79 @@
+---
+type: skill
+domain: architecture
+links: [Corpus_Callosum/CONSTITUTION.md, PULSE_OS.md]
+---
+
+# NETWORK_NOMAD
+> **ROLE:** CONNECTIVITY ARCHITECT
+> **TRIGGER:** "API CALL"
+
+## Core Mandate
+The network is unreliable. The code must not be. Every external call gets a timeout, a retry, and a fallback.
+
+## Step-by-Step Protocol
+1. **Brain check**: `python Autonomic_System/Utilities/Tools/brain_query.py --query "network patterns for <API/service>"`
+2. **Wrap every external call** in retry logic with exponential backoff: `delay = min(2^attempt * 100ms, 30s)`, max 5 retries.
+3. **Set explicit timeouts** on all requests: connect=5s, read=30s. Never use `timeout=None`.
+4. **Implement circuit breaker**: After 3 consecutive failures, stop calling for 60 seconds. Log the circuit-open event.
+5. **Verify TLS and sanitize headers**: No plaintext HTTP. Strip `Server`, `X-Powered-By` from responses.
+
+## Exponential Backoff Formula
+```
+delay = min(2^attempt * 100ms, max_delay)
+```
+| Attempt | Delay | Cumulative |
+|---|---|---|
+| 1 | 200ms | 200ms |
+| 2 | 400ms | 600ms |
+| 3 | 800ms | 1.4s |
+| 4 | 1600ms | 3.0s |
+| 5 | 3200ms | 6.2s |
+
+Add jitter: `delay = delay * (0.5 + random.random() * 0.5)` to prevent thundering herd.
+
+## Good Example
+```python
+import time, random, requests
+
+def resilient_call(url: str, max_retries: int = 5) -> requests.Response:
+    for attempt in range(max_retries):
+        try:
+            resp = requests.get(url, timeout=(5, 30))
+            resp.raise_for_status()
+            return resp
+        except requests.RequestException:
+            if attempt == max_retries - 1:
+                raise
+            delay = min(2 ** attempt * 0.1, 30)
+            delay *= 0.5 + random.random() * 0.5  # jitter
+            time.sleep(delay)
+```
+
+## Metrics & Thresholds
+| Metric | Threshold |
+|---|---|
+| Connect timeout | 5 seconds max |
+| Read timeout | 30 seconds max |
+| Max retries | 5 attempts |
+| Circuit breaker trigger | 3 consecutive failures |
+| Circuit breaker cooldown | 60 seconds |
+| Max backoff cap | 30 seconds |
+
+## Anti-Patterns
+- **`timeout=None`**: Hangs forever if server is down. Always set both connect and read timeouts.
+- **Retry without backoff**: Hammering a failing server makes it worse. Always use exponential delay.
+- **Catching `requests.RequestException` and returning `None`**: Caller won't know the call failed. Raise or return a result object with error info.
+
+## Tools to Use
+- `brain_query.py --query "API retry patterns"` -- check brain for prior network lessons
+- `pulse_relay.py --tasks "Add retry logic:architecture:fast"` -- delegate to agents
+- `pulse_save.py --learnings "..." --failures "..."` -- record network incidents
+
+## Verification Checklist
+- [ ] Every `requests.get/post` call has explicit `timeout=(connect, read)`
+- [ ] Retry logic uses exponential backoff with jitter
+- [ ] Circuit breaker implemented for repeated-failure APIs
+- [ ] No plaintext HTTP URLs (all HTTPS)
+- [ ] No `timeout=None` anywhere in codebase
+- [ ] Rate limiting respected (check `Retry-After` header)

pulse_os-10.0.0/.cursor/skills/Architecture/SYSTEM_HARMONIZER.md

@@ -0,0 +1,60 @@
+---
+type: skill
+domain: architecture
+links: [Corpus_Callosum/CONSTITUTION.md, PULSE_OS.md]
+---
+
+# SYSTEM_HARMONIZER.md
+> **ROLE:** COHESION ARCHITECT
+> **TRIGGER:** "INTEGRATE ALL" / "COMPATIBILITY" / "CONTRACT"
+
+## Step-by-Step Protocol
+1. **Map integration surface** — run `brain_query.py --query "system integration points"`. List every inter-module call, shared file, and message format. Build a dependency matrix.
+2. **Define API contracts** — every boundary gets a contract: JSON Schema for files, Pydantic models for APIs, TypedDict for internal dicts. Pin field names, types, required/optional.
+3. **Build compatibility matrix** — table of Module x Module with status (PASS/FAIL/UNTESTED). Run contract tests: provider publishes schema, consumer validates against it.
+4. **Resolve conflicts** — when skills contradict (e.g., ZERO_TRUST blocks LATENCY_LAYER), apply priority: Constitution > LAWS.md > ASOP > skill. Document the resolution in Evidence/.
+5. **Verify end-to-end** — trace a request from Sensory_Input through Brain to output. Confirm every handoff matches its contract. No silent data drops.
+
+## Metrics & Thresholds
+- **Contract coverage:** 100% of inter-module boundaries have a schema
+- **Compatibility matrix fill rate:** >90% cells tested (no UNTESTED between active modules)
+- **Breaking change frequency:** 0 unannounced breaking changes per release
+- **Integration test pass rate:** >=99% on main branch
+- **Conflict resolution time:** <1 hour from detection to documented resolution
+
+## Good Example
+```python
+# Contract test: pulse_save output matches brain_query input
+from pydantic import BaseModel, validator
+
+class LearningEntry(BaseModel):
+    agent: str
+    content: str  # min 25 chars, 5+ words (quality gate)
+    timestamp: str
+    source: str
+
+    @validator("content")
+    def validate_quality(cls, v):
+        assert len(v) >= 25, "Too short for brain storage"
+        assert len(v.split()) >= 5, "Need 5+ words"
+        return v
+
+# Provider (pulse_save) and consumer (brain_query) both validate against this
+```
+
+## Anti-Patterns
+1. **Implicit contracts** — "it just sends a dict" guarantees nothing; always define schemas.
+2. **Bilateral fixes** — when A and B break, fix the contract, not both sides independently. Law 10 (Twin Paradox) applies.
+3. **Skipping the matrix** — untested integration paths fail in production. If two modules can talk, test that they do.
+
+## Tools to Use
+- `python Autonomic_System/Utilities/Tools/brain_query.py --query "integration contracts"` — find existing contracts and past breakages
+- `python Autonomic_System/Utilities/Tools/pulse_relay.py --tasks "Contract Test:architecture:standard"` — delegate contract writing
+- `python Autonomic_System/Utilities/Tools/pulse_save.py --agent harmonizer --learnings "what you learned"` — record integration decisions
+
+## Verification Checklist
+- [ ] Every inter-module boundary has a Pydantic/JSON Schema contract
+- [ ] Compatibility matrix exists and >90% cells are PASS/FAIL (not UNTESTED)
+- [ ] No module reads another module's internal state directly (use APIs)
+- [ ] Conflict resolutions documented in Hippocampus/Evidence/
+- [ ] End-to-end trace passes: input -> processing -> output with zero silent drops

pulse_os-10.0.0/.cursor/skills/Architecture/UI_ALCHEMIST.md

@@ -0,0 +1,60 @@
+---
+type: skill
+domain: architecture
+links: [Corpus_Callosum/CONSTITUTION.md, PULSE_OS.md]
+---
+
+# UI_ALCHEMIST.md
+> **ROLE:** UX/UI DESIGNER
+> **TRIGGER:** "MAKE IT PRETTY" / "UI" / "COMPONENT"
+
+## Step-by-Step Protocol
+1. **Query existing patterns** — run `brain_query.py --query "UI components design system"`. Check for established spacing, color, and typography decisions.
+2. **Define component hierarchy** — Atoms (Button, Input, Label) -> Molecules (SearchBar, FormField) -> Organisms (Header, TaskCard) -> Templates -> Pages. Never skip levels.
+3. **Set render budgets** — every component must render in <16ms (60fps). Measure with `React.Profiler` or `performance.mark()`. Break up work exceeding 50ms with `requestIdleCallback`.
+4. **Apply accessibility (WCAG 2.1 AA)** — contrast ratio >=4.5:1 for text, >=3:1 for large text. All interactive elements keyboard-navigable. All images have `alt`. All forms have `<label>`.
+5. **Mobile-first implementation** — write base CSS for 320px, then `@media (min-width: 768px)` for tablet, `@media (min-width: 1024px)` for desktop. Test on real devices.
+
+## Metrics & Thresholds
+- **Render time:** <16ms per frame (60fps), <50ms for initial component mount
+- **Contrast ratio:** >=4.5:1 normal text, >=3:1 large text (WCAG 2.1 AA)
+- **Lighthouse accessibility score:** >=90
+- **Bundle size per component:** <10KB gzipped (atoms), <25KB (molecules), <50KB (organisms)
+- **Spacing system:** multiples of 4px only (4, 8, 12, 16, 24, 32, 48, 64)
+
+## Good Example
+```tsx
+// Atom: accessible button with render budget enforcement
+const PulseButton = ({ label, onClick, variant = "primary" }: Props) => {
+  // Render budget: this component must mount in <16ms
+  return (
+    <button
+      className={`px-4 py-2 rounded-lg font-medium
+        ${variant === "primary" ? "bg-blue-600 text-white" : "bg-gray-200 text-gray-800"}
+        focus:ring-2 focus:ring-offset-2 focus:ring-blue-500
+        hover:opacity-90 transition-opacity duration-150`}
+      onClick={onClick}
+      aria-label={label}  /* WCAG: always provide accessible name */
+    >
+      {label}
+    </button>
+  );
+};
+```
+
+## Anti-Patterns
+1. **Inline styles over design tokens** — kills consistency; always use spacing/color tokens from the system.
+2. **Skipping keyboard navigation** — 15% of users rely on it; every `onClick` needs `onKeyDown` (Enter/Space).
+3. **Rendering lists without virtualization** — >50 items causes jank; use `react-window` or `virtuoso` for long lists.
+
+## Tools to Use
+- `python Autonomic_System/Utilities/Tools/brain_query.py --query "UI design tokens"` — find existing design decisions
+- `python Autonomic_System/Utilities/Tools/pulse_relay.py --tasks "Accessibility Audit:architecture:fast"` — delegate a11y sweep
+- `python Autonomic_System/Utilities/Tools/pulse_save.py --agent ui_alchemist --learnings "what you learned"` — save design decisions
+
+## Verification Checklist
+- [ ] All components use 4px spacing grid (no arbitrary values)
+- [ ] Render budget met: <16ms per frame, verified with Profiler
+- [ ] WCAG 2.1 AA: contrast >=4.5:1, all inputs labeled, keyboard-navigable
+- [ ] Component hierarchy follows Atomic Design (atoms -> molecules -> organisms)
+- [ ] Mobile-first: base styles at 320px, progressive enhancement upward