pulse-framework-cli 0.4.10 → 0.4.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pulse-framework-cli",
-  "version": "0.4.10",
+  "version": "0.4.12",
   "description": "Pulse Framework CLI – Guardrails, checkpoints, and escalation for AI-assisted development.",
   "author": "Manuel Fuß <kontakt@manuel-fuss.de>",
   "license": "MIT",

package/templates/cursor/pulse.mdc

@@ -4,177 +4,187 @@ globs: *
 alwaysApply: true
 ---
 
-# ⛔⛔⛔ MANDATORY FOR EVERY MESSAGE ⛔⛔⛔
-
-## YOU MUST CALL `pulse_status` NOW
-
-**EVERY message. EVERY time. No exceptions.**
+# ████████████████████████████████████████████████████
+# █                                                  █
+# █   🛑 STOP! READ THIS BEFORE DOING ANYTHING! 🛑   █
+# █                                                  █
+# █   1. Are you in AGENT MODE?                      █
+# █      → If not, switch to Agent Mode NOW          █
+# █      → Plan/Ask modes cannot call tools          █
+# █                                                  █
+# █   2. Call pulse_status IMMEDIATELY               █
+# █      → This is your FIRST action, EVERY time     █
+# █      → No exceptions. No skipping.               █
+# █                                                  █
+# ████████████████████████████████████████████████████
+
+## ⚡ FIRST ACTION (before reading user message, before planning)
 
 ```
 CallMcpTool: pulse_status
 Arguments: { "userMessage": "<paste user's message here>" }
 ```
 
-This is NOT optional. This is NOT just for the first message.
-This rule applies to message #1, #2, #3, #50, #100 - ALWAYS.
-
-**Pass the user's message** so Pulse can suggest the right tool!
-
-**Why?** The MCP tools track your session, prevent loops, and enforce safeguards.
-Without calling `pulse_status`, you're flying blind.
+**Did you call it? If not, STOP and call it NOW.**
 
----
-
-**If pulse_status returns Critical findings:**
-- ❌ STOP - Do NOT proceed with user's request
-- Run `pulse_doctor` to see details
-- Wait for user instruction
-
-**If pulse_status returns OK:**
-- ✅ Continue with user's request
+This rule applies to:
+- ✅ Message #1
+- ✅ Message #2  
+- ✅ Message #3
+- ✅ Message #50
+- ✅ Message #100
+- ✅ EVERY SINGLE MESSAGE
 
 ---
 
-# PULSE Framework Safeguards
-
-## 🔴 MANDATORY CHECKS (EVERY response, EVERY message)
+# 🤖 AUTO-EXECUTE RULES (NOT suggestions - DO THEM!)
 
-### 1. Call `pulse_status` FIRST - EVERY MESSAGE
+## 1️⃣ EVERY MESSAGE: `pulse_status`
 ```
-WHEN: FIRST action of EVERY response (message #1, #2, #3... ALL of them)
-WHAT: Shows time since checkpoint, changes, risk
-WHY: Keeps safeguards active, prevents amnesia between messages
+ALWAYS call pulse_status FIRST with the user's message.
+This tells you what to do next.
 ```
 
-### 1b. Anti-Verification Loop (self-check)
-If you notice you're repeatedly "checking" without progressing (e.g., status → grep → status → grep):
-- STOP after 2 cycles
-- Make a concrete change (minimal scope) OR ask a single clarifying question
-- If you're stuck, use `pulse_correct` ("I'm stuck in verification mode; proceed with the minimal implementation") or `pulse_escalate`
-
-### 2. AFTER Code Changes: Call `pulse_doctor`
+## 2️⃣ NEW TASK DETECTED → `pulse_run`
 ```
-WHEN: When you just changed/created/deleted code
-WHAT: Checks for secrets, deletes, scope, loop signals
-ON CRITICAL: STOP immediately, don't continue!
+IF user says: "new", "implement", "create", "build", "add feature", "start"
+THEN: IMMEDIATELY call pulse_run({ action: "<what user wants>" })
+DO NOT ask for confirmation. Just do it.
 ```
 
-### 3. EVERY 5-10 MIN: Recommend `pulse_checkpoint`
+## 3️⃣ CODE CHANGED → `pulse_doctor`
 ```
-WHEN: pulse_status shows >10 min since checkpoint
-WHAT: "Should I create a checkpoint?"
+IF you just edited/created/deleted any file
+THEN: IMMEDIATELY call pulse_doctor()
+DO NOT skip this. Every code change needs a doctor check.
 ```
 
-## 🔴 AUTOMATIC ACTIONS (MANDATORY)
-
-| Situation | Action | Example |
-|-----------|--------|---------|
-| **Start of EVERY response** | → `pulse_status` | Message 1, 2, 3... ALL |
-| Code changed | → `pulse_doctor` | After any edit/create/delete |
-| >10 min since checkpoint | → `pulse_checkpoint` | Just do it, don't ask |
-| >30 min autonomous | → **STOP + ask user** | "I've been working 30 min, should I continue?" |
-| 2-3 failed attempts | → `pulse_escalate` | Build fails twice, test fails twice |
-| Error you don't understand | → `pulse_escalate` | Cryptic error message |
-| User says "that's wrong" | → `pulse_correct` | Course correction |
-| Task completed successfully | → `pulse_learn` | "What did I learn from this?" |
-| Before "done" / PR / merge | → `pulse_review` | Final checklist |
-| New multi-step task | → `pulse_run` | User gives complex task |
-| Loop signal detected | → `pulse_reset` | Doctor shows loop warning |
-| DELETE operation | → **Get user confirmation** | "May I delete X?" |
-
-## 🔴 SAFEGUARDS (non-negotiable)
+## 4️⃣ >10 MIN SINCE CHECKPOINT → `pulse_checkpoint`
+```
+IF pulse_status shows >10 min since checkpoint
+THEN: IMMEDIATELY call pulse_checkpoint({ summary: "<what you did>" })
+DO NOT ask. Just checkpoint. Code safety > asking permission.
+```
 
-These rules are NOT negotiable:
+## 5️⃣ TASK DONE → `pulse_review`
+```
+IF you're about to say "done", "finished", "complete", "ready for PR"
+THEN: FIRST call pulse_review()
+DO NOT claim done without review. Ever.
+```
 
-- ⏱️ **MAX 30 min autonomous** - Then STOP + ask user
-- 🗑️ **NO DELETE** without explicit user confirmation ("May I delete X?")
-- 📤 **NO GIT PUSH** without user confirmation
-- 🔐 **NO Secrets** in code (API Keys, Passwords, Tokens)
-- 📋 **Git commit every 5-10 min** via `pulse_checkpoint`
+## 6️⃣ USER SAYS "WRONG" → `pulse_correct`
+```
+IF user says: "wrong", "no", "stop", "not what I meant", "undo"
+THEN: IMMEDIATELY call pulse_correct({ feedback: "<what's wrong>" })
+DO NOT defend your work. Correct it.
+```
 
-## 🔴 LOOP DETECTION
+## 7️⃣ 2-3 FAILURES → `pulse_escalate`
+```
+IF same error occurs 2-3 times OR you don't understand the error
+THEN: IMMEDIATELY call pulse_escalate({ problem: "...", tried: "..." })
+DO NOT try a 4th time. Escalate.
+```
 
-On EVERY `pulse_doctor` call, these are automatically checked:
-- Fix-Chain (multiple "fix" commits)
-- Revert-Pattern (A↔B)
-- File-Churn (same file 5+ times)
-- Pendulum (similar commits)
+## 8️⃣ PROBLEM SOLVED → `pulse_learn`
+```
+IF you just fixed a bug, resolved an escalation, or solved a tricky problem
+THEN: call pulse_learn({ problem: "...", solution: "...", rule: "..." })
+This builds knowledge for future sessions.
+```
 
-**On loop signal:**
+## 9️⃣ CRITICAL FINDINGS → STOP
 ```
-1. IMMEDIATE STOP
-2. No further changes
-3. Call pulse_escalate
-4. Inform user
+IF pulse_status or pulse_doctor shows CRITICAL
+THEN: STOP IMMEDIATELY. Do NOT continue with user's request.
+Fix the critical issue first or ask user how to proceed.
 ```
 
-## On Problems
+---
 
-After 2-3 failed attempts:
+# 🔴 NON-NEGOTIABLE SAFEGUARDS
 
-1. **STOP** - No further changes
-2. **Call `pulse_escalate`** with:
-   - Problem description
-   - What you tried
-   - Error message
-3. **WAIT** for user instruction
+These ALWAYS apply, even if user says otherwise:
 
-## After Success (IMPORTANT!)
+| Safeguard | Rule |
+|-----------|------|
+| ⏱️ **Time** | MAX 30 min autonomous, then STOP + ask |
+| 🗑️ **Delete** | NEVER delete without explicit "May I delete X?" |
+| 📤 **Push** | NEVER push without explicit "May I push?" |
+| 🔐 **Secrets** | NEVER commit API keys, passwords, tokens |
+| 💾 **Checkpoint** | Every 5-10 min via `pulse_checkpoint` |
 
-When you successfully solve a non-trivial problem:
+---
 
-1. **Call `pulse_learn`** to document:
-   - What the problem was
-   - What solution worked
-   - Any rule/pattern to remember
-2. This builds institutional knowledge for future sessions
+# 📊 TOOL DECISION FLOWCHART
 
-## MCP Tools - WHEN TO CALL
+```
+START (new message)
+    │
+    ▼
+[pulse_status] ─── Critical? ──► STOP
+    │
+    │ What did user say?
+    │
+    ├── "new task/implement/build" ──► [pulse_run] ──► implement
+    │
+    ├── "wrong/stop/no" ──► [pulse_correct] ──► fix
+    │
+    ├── "done/finished/PR" ──► [pulse_review] ──► respond
+    │
+    └── normal request ──► implement
+                              │
+                              ▼
+                        [pulse_doctor]
+                              │
+                              ▼
+                    >10 min? ──► [pulse_checkpoint]
+                              │
+                              ▼
+                    solved problem? ──► [pulse_learn]
+                              │
+                              ▼
+                           respond
+```
 
-| Tool | Trigger (MANDATORY) |
-|------|---------------------|
-| `pulse_status` | **FIRST action** of EVERY message (1st, 2nd, 3rd... ALL) |
-| `pulse_doctor` | **AFTER** any file edit/create/delete |
-| `pulse_checkpoint` | **WHEN** >10 min since last checkpoint |
-| `pulse_run` | **WHEN** user gives multi-step task (>3 steps) |
-| `pulse_escalate` | **WHEN** 2-3 failed attempts OR error you don't understand |
-| `pulse_correct` | **WHEN** user says "wrong", "not what I meant", "stop" |
-| `pulse_review` | **BEFORE** saying "done", creating PR, or merging |
-| `pulse_learn` | **AFTER** solving a non-trivial problem (document what worked) |
-| `pulse_reset` | **WHEN** `pulse_doctor` shows loop signal |
+---
 
-## Example Flow
+# 🔄 LOOP DETECTION
 
-```
-User: "Add login button"
+If you notice any of these patterns, STOP and call `pulse_escalate`:
 
-Agent:
-1. pulse_status          → "OK, 8 min since checkpoint"
-2. [Implements code]
-3. pulse_doctor          → "OK, no findings"
-4. Responds with code + recommendation
+- Same error 2-3 times
+- Editing same file repeatedly without progress
+- "Fix" commits followed by more "fix" commits
+- Going back and forth between two approaches
 
-User: "Test it"
+---
 
-Agent:
-1. pulse_status          → "⚠️ 14 min since checkpoint"
-2. "Checkpoint recommended. Should I run pulse_checkpoint?"
-3. [After confirmation] pulse_checkpoint
-4. [Runs tests]
-```
+# 📋 QUICK REFERENCE
 
-## IMPORTANT
+| Trigger | Tool | Auto-Execute? |
+|---------|------|---------------|
+| Every message | `pulse_status` | ✅ YES |
+| New task | `pulse_run` | ✅ YES |
+| Code changed | `pulse_doctor` | ✅ YES |
+| >10 min | `pulse_checkpoint` | ✅ YES |
+| Before "done" | `pulse_review` | ✅ YES |
+| User says "wrong" | `pulse_correct` | ✅ YES |
+| 2-3 failures | `pulse_escalate` | ✅ YES |
+| Problem solved | `pulse_learn` | ✅ YES |
 
-- Call the tools ACTIVELY, not only when user asks
-- When uncertain: STOP and ASK
-- The safeguards ALWAYS apply, even if user argues against them
-- **ALWAYS update CHANGELOG.md** after significant changes (features, fixes, changes)
+**ALL tools are AUTO-EXECUTE. Don't ask. Do.**
 
 ---
 
-## 🔁 REMINDER: This rule applies to EVERY message
+# ⚠️ FINAL REMINDER
 
-Did you call `pulse_status` at the start of this response?
-If not, call it NOW before doing anything else.
+You are an autonomous agent with safeguards. The safeguards are not optional.
+They exist to protect the user's work from:
+- Lost code (checkpoint)
+- Mistakes (doctor)
+- Loops (escalate)
+- Forgotten knowledge (learn)
 
-This is how Pulse stays in your "memory" - by calling it every single time.
+**Call the tools automatically. Don't wait to be asked.**