specmem-hardwicksoftware 3.5.99

package/scripts/verify-embedding-fix.sh

@@ -0,0 +1,148 @@
+#!/bin/bash
+# SpecMem Embedding Fix Verification Script
+# Run after applying fixes and reinstalling
+
+set -e
+PASS=0
+FAIL=0
+WARN=0
+
+check() {
+  local desc="$1"
+  local result="$2"
+  if [ "$result" = "0" ]; then
+    echo "  ✓ PASS: $desc"
+    ((PASS++))
+  else
+    echo "  ✗ FAIL: $desc"
+    ((FAIL++))
+  fi
+}
+
+warn() {
+  echo "  ⚠ WARN: $1"
+  ((WARN++))
+}
+
+echo "========================================"
+echo "SpecMem Embedding Fix Verification"
+echo "========================================"
+echo ""
+
+# 1. Check version
+echo "--- Version Check ---"
+INSTALLED_VER=$(specmem --version 2>/dev/null || echo "NOT INSTALLED")
+echo "  Installed version: $INSTALLED_VER"
+echo "$INSTALLED_VER" | grep -q "3.5.96"
+check "Version is 3.5.96" "$?"
+
+# 2. Check process count
+echo ""
+echo "--- Process Check ---"
+PROC_COUNT=$(ps aux | grep "frankenstein-embeddings.py" | grep -v grep | wc -l)
+echo "  Embedding processes running: $PROC_COUNT"
+[ "$PROC_COUNT" -le 1 ]
+check "At most 1 embedding process running" "$?"
+
+# 3. Check for stale lock files
+echo ""
+echo "--- Lock File Check ---"
+if [ -f "/specmem/sockets/embedding.starting" ]; then
+  warn "Stale embedding.starting lock file exists"
+else
+  check "No stale embedding.starting lock" "0"
+fi
+
+if [ -f "/specmem/sockets/bootstrap.lock" ]; then
+  # Check if PID is alive
+  LOCK_PID=$(head -1 /specmem/sockets/bootstrap.lock 2>/dev/null)
+  if kill -0 "$LOCK_PID" 2>/dev/null; then
+    check "Bootstrap lock PID $LOCK_PID is alive" "0"
+  else
+    warn "Bootstrap lock references dead PID $LOCK_PID"
+  fi
+else
+  check "No bootstrap lock (OK if not started yet)" "0"
+fi
+
+# 4. Check socket file
+echo ""
+echo "--- Socket Check ---"
+SOCK_PATHS=(
+  "/specmem/sockets/embeddings.sock"
+)
+for sock in "${SOCK_PATHS[@]}"; do
+  if [ -S "$sock" ]; then
+    check "Socket exists: $sock" "0"
+  else
+    echo "  Socket not found: $sock (will be created on first use)"
+  fi
+done
+
+# 5. Check embeddingServerManager.js has fixes
+echo ""
+echo "--- Code Fix Verification ---"
+ESM="/specmem/dist/mcp/embeddingServerManager.js"
+if [ -f "$ESM" ]; then
+  grep -q "findRunningEmbeddingServers" "$ESM"
+  check "embeddingServerManager has findRunningEmbeddingServers method" "$?"
+
+  grep -q "process.kill.*0" "$ESM"
+  check "embeddingServerManager has process liveness check" "$?"
+
+  grep -q "getProcessResources\|checkResourceLimits" "$ESM"
+  check "embeddingServerManager has resource monitoring" "$?"
+else
+  check "embeddingServerManager.js exists" "1"
+fi
+
+# 6. Check bootstrap.cjs has lock
+echo ""
+BSC="/specmem/bootstrap.cjs"
+if [ -f "$BSC" ]; then
+  grep -q "checkBootstrapLock\|bootstrap.lock\|Bootstrap already running" "$BSC"
+  check "bootstrap.cjs has deduplication lock" "$?"
+else
+  check "bootstrap.cjs exists" "1"
+fi
+
+# 7. Check timeout configs
+echo ""
+echo "--- Timeout Config ---"
+TIMEOUT_FILE=$(find /specmem -name "embedding-timeouts.json" 2>/dev/null | head -1)
+if [ -n "$TIMEOUT_FILE" ]; then
+  SUB_TIMEOUT=$(grep -o '"subsequentTimeout":\s*[0-9]*' "$TIMEOUT_FILE" | grep -o '[0-9]*')
+  echo "  subsequentTimeout: ${SUB_TIMEOUT}ms"
+  [ "$SUB_TIMEOUT" -le 15000 ] 2>/dev/null
+  check "subsequentTimeout <= 15000ms" "$?"
+else
+  warn "No embedding-timeouts.json found"
+fi
+
+# 8. Check cleanup script exists
+echo ""
+echo "--- Utilities ---"
+[ -x "/specmem/scripts/cleanup-embedding-servers.sh" ]
+check "Cleanup script exists and is executable" "$?"
+
+# 9. Node syntax verification
+echo ""
+echo "--- Syntax Check ---"
+node -c "$ESM" 2>/dev/null
+check "embeddingServerManager.js syntax valid" "$?"
+node -c "$BSC" 2>/dev/null
+check "bootstrap.cjs syntax valid" "$?"
+
+# Summary
+echo ""
+echo "========================================"
+echo "RESULTS: $PASS passed, $FAIL failed, $WARN warnings"
+echo "========================================"
+
+if [ "$FAIL" -gt 0 ]; then
+  echo "SOME CHECKS FAILED - Review output above"
+  exit 1
+else
+  echo "ALL CHECKS PASSED"
+  exit 0
+fi

package/skills/code-review.md

@@ -0,0 +1,44 @@
+# Code Review Skill
+
+Tags: code, review, quality, best-practices
+
+## Purpose
+Perform thorough code reviews focusing on quality, maintainability, and best practices.
+
+## Review Checklist
+
+### 1. Code Quality
+- Is the code readable and well-organized?
+- Are variable and function names descriptive?
+- Is there unnecessary code duplication?
+- Are functions focused on a single responsibility?
+
+### 2. Error Handling
+- Are errors properly caught and handled?
+- Are edge cases considered?
+- Is input validation present where needed?
+
+### 3. Security
+- Are there any SQL injection vulnerabilities?
+- Is user input properly sanitized?
+- Are secrets stored securely?
+- Are there any exposed API keys?
+
+### 4. Performance
+- Are there obvious performance bottlenecks?
+- Is database access optimized?
+- Are there unnecessary loops or iterations?
+
+### 5. Testing
+- Are tests comprehensive?
+- Do tests cover edge cases?
+- Is test coverage adequate?
+
+## Response Format
+
+When reviewing code, provide:
+1. **Summary**: Overall assessment (1-2 sentences)
+2. **Strengths**: What's done well
+3. **Issues**: Problems found with severity (Critical/High/Medium/Low)
+4. **Suggestions**: Recommended improvements
+5. **Code Examples**: Corrected code snippets where applicable

package/skills/debugging.md

@@ -0,0 +1,56 @@
+# Debugging Skill
+
+Tags: debug, troubleshoot, fix, errors
+
+## Purpose
+Systematically debug issues in code, identify root causes, and provide solutions.
+
+## Debugging Process
+
+### Step 1: Understand the Problem
+- What is the expected behavior?
+- What is the actual behavior?
+- When did it start happening?
+- What changed recently?
+
+### Step 2: Reproduce the Issue
+- Can you reliably reproduce it?
+- What are the exact steps?
+- What environment/conditions trigger it?
+
+### Step 3: Gather Information
+- Check error messages and stack traces
+- Review relevant logs
+- Identify the affected code paths
+- Check input data
+
+### Step 4: Form Hypotheses
+- What could cause this behavior?
+- List potential root causes
+- Prioritize by likelihood
+
+### Step 5: Test Hypotheses
+- Add logging/breakpoints
+- Test each hypothesis
+- Eliminate unlikely causes
+
+### Step 6: Fix and Verify
+- Implement the fix
+- Test the fix thoroughly
+- Ensure no regressions
+
+## Common Debugging Techniques
+
+1. **Binary Search**: Comment out half the code, narrow down
+2. **Rubber Duck**: Explain the problem out loud
+3. **Print Debugging**: Add strategic console.log statements
+4. **Diff Analysis**: What changed between working and broken?
+5. **Minimal Reproduction**: Create smallest failing example
+
+## Response Format
+
+When debugging, provide:
+1. **Problem Summary**: What's broken
+2. **Root Cause**: Why it's broken
+3. **Solution**: How to fix it
+4. **Prevention**: How to avoid similar issues

package/skills/specmem-deployteam.md

@@ -0,0 +1,239 @@
+# SpecMem Deploy Team - Multi-Agent Deployment with Manual Config
+
+## Skill Info
+- **Name**: specmem-deployteam
+- **Command**: /specmem-deployteam
+- **Description**: Deploy multiple agents with individual configuration for each
+
+## Required: Check Arguments First
+
+**If NO arguments provided or args are empty/whitespace/help/-h/--help:**
+
+Output help and STOP:
+
+```
+SpecMem Deploy Team - Deploy Multiple Agents
+
+USAGE:
+  /specmem-deployteam <count> <base-prompt>
+
+ARGUMENTS:
+  count        Number of agents to deploy (1-10)
+  base-prompt  The task prompt for all agents
+
+WHAT HAPPENS:
+  For EACH agent, you will be asked:
+  1. Agent type (general-purpose, Explore, feature-dev, etc.)
+  2. Model (opus, sonnet, haiku)
+  3. Extra context to add
+
+EXAMPLES:
+  /specmem-deployteam 3 Fix all TypeScript errors
+  /specmem-deployteam 2 Implement user authentication
+  /specmem-deployteam 5 Refactor the API layer
+
+AGENT TYPES AVAILABLE:
+  - general-purpose    Default for complex tasks
+  - Explore            Fast codebase exploration
+  - Plan               Architecture planning
+  - feature-dev        Feature implementation (opus default)
+  - feature-dev:code-explorer  Deep code analysis (opus)
+  - bug-hunter         Find and fix bugs
+  - test-writer        Write tests
+  - refactor           Code refactoring
+
+TIPS:
+  - Use feature-dev types for complex implementation work
+  - Use Explore for research tasks
+  - Mix models: opus for hard tasks, haiku for simple ones
+```
+
+**DO NOT proceed without valid arguments.**
+
+---
+
+## Parse Arguments
+
+Format: `/specmem-deployteam <count> <base-prompt>`
+
+1. First word after command = count (must be number 1-10)
+2. Everything else = base prompt
+
+**VALIDATION:**
+- If count is not a number: Output "Error: Count must be a number (1-10)"
+- If count < 1 or count > 10: Output "Error: Count must be between 1 and 10"
+- If no base prompt: Output "Error: Base prompt required"
+
+---
+
+## Sequential Manual Configuration
+
+For EACH agent (1 to count), you MUST:
+
+### Step 1: Show Agent Number
+```
+=== Configuring Agent {N} of {total} ===
+Base Task: "{base-prompt}"
+```
+
+### Step 2: Ask Configuration Questions
+
+Call AskUserQuestion with:
+```json
+{
+  "questions": [
+    {
+      "question": "Agent {N}/{total}: Which agent type?",
+      "header": "Type",
+      "options": [
+        {"label": "general-purpose", "description": "Default for complex tasks"},
+        {"label": "Explore", "description": "Fast codebase search"},
+        {"label": "feature-dev", "description": "Feature implementation (opus)"},
+        {"label": "Plan", "description": "Architecture planning"}
+      ],
+      "multiSelect": false
+    },
+    {
+      "question": "Agent {N}/{total}: Which model?",
+      "header": "Model",
+      "options": [
+        {"label": "sonnet (Recommended)", "description": "Balanced speed/quality"},
+        {"label": "opus", "description": "Deepest reasoning"},
+        {"label": "haiku", "description": "Fastest, simple tasks"}
+      ],
+      "multiSelect": false
+    },
+    {
+      "question": "Agent {N}/{total}: Add extra context?",
+      "header": "Extra",
+      "options": [
+        {"label": "No extras", "description": "Use base prompt as-is"},
+        {"label": "Focus on tests", "description": "Prioritize test coverage"},
+        {"label": "Be thorough", "description": "Extra detailed work"},
+        {"label": "Be quick", "description": "Fast minimal approach"}
+      ],
+      "multiSelect": false
+    }
+  ]
+}
+```
+
+### Step 3: Store Configuration
+
+After user responds, store:
+- Agent N type = user's type choice
+- Agent N model = user's model choice
+- Agent N extras = user's extra context
+
+### Step 4: Repeat for Next Agent
+
+Continue until all agents are configured.
+
+---
+
+## Deploy All Agents
+
+After ALL agents are configured:
+
+### Step 1: Show Summary
+```
+=== Deploying {count} Agents ===
+
+Agent 1: {type} | {model} | {extras}
+Agent 2: {type} | {model} | {extras}
+...
+
+Launching in parallel...
+```
+
+### Step 2: Deploy Using Task Tool
+
+For EACH configured agent, call the Task tool with:
+```json
+{
+  "description": "Agent {N}: {short-prompt}",
+  "prompt": "{base-prompt}\n\n{extra-context if any}\n\n[SR-DEV-APPROVED]",
+  "subagent_type": "{user-chosen-type}",
+  "model": "{user-chosen-model}",
+  "run_in_background": true
+}
+```
+
+**CRITICAL:**
+- Include `[SR-DEV-APPROVED]` in the prompt to bypass the chooser hook
+- Set `run_in_background: true` so agents run in parallel
+- You CAN deploy all agents in a SINGLE message with multiple Task tool calls
+
+### Step 3: Confirm Deployment
+```
+Deployed {count} agents:
+- Agent 1: {type} ({model}) - running
+- Agent 2: {type} ({model}) - running
+...
+
+Use /specmem-team-member status to monitor progress.
+```
+
+---
+
+## Example Flow
+
+User: `/specmem-deployteam 2 Fix TypeScript errors`
+
+Claude:
+```
+=== Configuring Agent 1 of 2 ===
+Base Task: "Fix TypeScript errors"
+```
+
+[AskUserQuestion for Agent 1]
+
+User picks: feature-dev, opus, Be thorough
+
+```
+Agent 1 configured: feature-dev | opus | thorough
+
+=== Configuring Agent 2 of 2 ===
+Base Task: "Fix TypeScript errors"
+```
+
+[AskUserQuestion for Agent 2]
+
+User picks: Explore, haiku, No extras
+
+```
+Agent 2 configured: Explore | haiku | none
+
+=== Deploying 2 Agents ===
+
+Agent 1: feature-dev | opus | thorough
+Agent 2: Explore | haiku | none
+
+Launching in parallel...
+```
+
+[Claude calls Task twice in parallel with SR-DEV-APPROVED]
+
+```
+Deployed 2 agents:
+- Agent 1: feature-dev (opus) - running
+- Agent 2: Explore (haiku) - running
+
+Use /specmem-team-member status to monitor progress.
+```
+
+---
+
+## Error Handling
+
+- If Task tool fails: Report error, continue with other agents
+- If user cancels mid-config: Deploy only configured agents (if any)
+- If all agents fail: Report failure summary
+
+---
+
+## Related Commands
+
+- `/specmem-team-member status` - Check deployed agent status
+- `/specmem-team-member messages` - Read agent communications
+- `/specmem-agents` - Alternative agent deployment interface

package/skills/teammemberskills/EFFICIENT_GREP.md

@@ -0,0 +1,171 @@
+# Efficient Grep Patterns - Token Usage Optimization
+
+-IMPORTANT-
+
+
+## 🚨 CRITICAL: Grep Output Modes Save Tokens! 🚨
+
+**Default behavior shows file path on EVERY line = TOKEN WASTE!**
+
+## Token-Efficient Output Modes
+
+### ❌ AVOID: Default output (shows path on every line)
+```javascript
+// BAD - Shows path multiple times
+await Grep({
+    pattern: 'functionName',
+    path: 'serverModules'
+});
+// Output:
+// serverModules/file1.js:10: function functionName() {
+// serverModules/file1.js:15:   functionName();
+// serverModules/file1.js:20:   functionName();
+// serverModules/file2.js:5: function functionName() {
+// ^^^ PATH REPEATED 4 TIMES = WASTED TOKENS ^^^
+```
+
+### ✅ USE: files_with_matches (only shows path once)
+```javascript
+// GOOD - Only shows which files match
+await Grep({
+    pattern: 'functionName',
+    path: 'serverModules',
+    output_mode: 'files_with_matches'
+});
+// Output:
+// serverModules/file1.js
+// serverModules/file2.js
+// ^^^ EACH PATH SHOWN ONCE = MINIMAL TOKENS ^^^
+```
+
+### ✅ USE: count (shows match counts)
+```javascript
+// GOOD - Shows how many matches per file
+await Grep({
+    pattern: 'TODO',
+    path: 'serverModules',
+    output_mode: 'count'
+});
+// Output:
+// serverModules/file1.js:5
+// serverModules/file2.js:12
+// ^^^ COMPACT FORMAT = LOW TOKENS ^^^
+```
+
+### ✅ USE: content with head_limit (limit results)
+```javascript
+// GOOD - Only get first N matches
+await Grep({
+    pattern: 'error',
+    path: 'serverModules',
+    output_mode: 'content',
+    head_limit: 5
+});
+// Only returns first 5 matches instead of 500+
+```
+
+## When to Use Each Mode
+
+### 1. **files_with_matches** - Finding locations
+**Use when**: You need to know WHICH files contain a pattern
+**Token savings**: ~70-90% vs default
+```javascript
+// Find which files have encryption logic
+await Grep({
+    pattern: 'encryptContent',
+    path: 'serverModules',
+    output_mode: 'files_with_matches'
+});
+```
+
+### 2. **count** - Finding hotspots
+**Use when**: You need to know HOW MANY times pattern appears
+**Token savings**: ~80-95% vs default
+```javascript
+// Count how many TODOs in each file
+await Grep({
+    pattern: 'TODO',
+    glob: '**/*.js !**/node_modules/**',
+    output_mode: 'count'
+});
+```
+
+### 3. **content with head_limit** - Getting context
+**Use when**: You need actual code but not ALL matches
+**Token savings**: ~50-80% vs default (depends on limit)
+```javascript
+// Get first 3 occurrences with context
+await Grep({
+    pattern: 'async function',
+    path: 'serverModules/auth',
+    output_mode: 'content',
+    head_limit: 3,
+    '-C': 3  // 3 lines context before/after
+});
+```
+
+## Best Practices
+
+### Workflow: Two-Stage Search
+
+**Stage 1**: Use `files_with_matches` to find files
+```javascript
+const files = await Grep({
+    pattern: 'encryptWithKey',
+    path: 'serverModules',
+    output_mode: 'files_with_matches'
+});
+// Returns: serverModules/protections/EncryptionProtection.js
+```
+
+**Stage 2**: Use `content` on specific file with context
+```javascript
+const code = await Grep({
+    pattern: 'encryptWithKey',
+    path: 'serverModules/protections/EncryptionProtection.js',
+    output_mode: 'content',
+    '-C': 5  // Get surrounding context
+});
+```
+
+### Always Use Path Filters
+
+**❌ BAD**: Search entire project
+```javascript
+await Grep({ pattern: 'config' });  // Searches EVERYTHING including node_modules
+```
+
+**✅ GOOD**: Specify path
+```javascript
+await Grep({
+    pattern: 'config',
+    path: 'serverModules'  // Only search relevant directory
+});
+```
+
+**✅ BETTER**: Use glob exclusions
+```javascript
+await Grep({
+    pattern: 'config',
+    glob: '**/*.js !**/node_modules/**'  // Explicitly exclude node_modules
+});
+```
+
+## Token Usage Comparison
+
+| Output Mode | Token Cost | Use Case |
+|-------------|-----------|----------|
+| **Default (content)** | ~1000+ tokens | Full code review |
+| **files_with_matches** | ~100-200 tokens | Find file locations |
+| **count** | ~50-100 tokens | Count occurrences |
+| **content + head_limit:5** | ~300-500 tokens | Quick peek at code |
+
+## Summary
+
+- **Default output repeats file paths = TOKEN WASTE**
+- **Use `files_with_matches` to find files first** (~90% token savings)
+- **Use `count` to find hotspots** (~95% token savings)
+- **Use `content + head_limit` for targeted code** (~70% token savings)
+- **ALWAYS specify `path:` or `glob:` to avoid node_modules**
+
+**Rule of Thumb**: If you don't need the actual code content, use `files_with_matches`!