shynlee04/hivemind-plugin/debug-orchestration

DEBUGGING IS AN ORCHESTRATION, NOT A SEQUENCE

// Event hook triggers
"event": async (event) => {
  if (event.type === "lsp.diagnostics.publish") {
    // Extract diagnostic info
    const { file, errors } = event.data
    // Queue for investigation
  }
}

const eventClassification = {
  severity: "error|warning|hint",
  category: "syntax|type|runtime|test",
  source: "lsp|test|manual",
  actionable: true | false
}

// Before debugging, preserve context
hivemind_session({
  action: "start",
  mode: "quick_fix",
  focus: "Debug: [event_summary]"
})
// Save current state
hivemind_anchor({
  action: "save",
  key: "pre_debug_state",
  value: JSON.stringify(stateSnapshot)
})

// Mark where debugging starts
hivemind_memory({
  action: "save",
  shelf: "debug_sessions",
  content: `Debug session started: ${timestamp}`,
  tags: "debug,started"
})

Is the issue reproducible?
├── YES → Is the root cause obvious?
│   ├── YES → Use systematic-debugging-hivemind
│   └── NO → Use parallel-debugging-hivemind
└── NO → Use systematic-debugging-hivemind + extended evidence gathering

const strategy = selectDebugStrategy({
  reproducible: boolean,
  obvious: boolean,
  complexity: "low|medium|high",
  timeConstraint: "urgent|normal|exploratory"
})

// Based on strategy, inject appropriate skills
const skillsToInject = [
  "systematic-debugging-hivemind",  // Always
  // Plus based on strategy:
  "parallel-debugging-hivemind",     // If parallel selected
  "evidence-discipline"               // If verification critical
]

while (!resolved && attempts < maxAttempts) {
  // Gather evidence
  // Form hypothesis
  // Test hypothesis
  // Verify fix
  
  // If stuck:
  // Call hivemind_inspect({ action: "drift" })
  // If drift < 40: compact_session and continue
}

// Run verification suite
await bash({ command: "npm test && npx tsc --noEmit" })
// Check no regressions

hivemind_memory({
  action: "save",
  shelf: "solutions",
  content: `
Root Cause: [X]
Symptoms: [Y]
Fix Applied: [Z]
Verification: [W]
  `,
  tags: "debug,resolved,[category]"
})

// Remove debug anchors
hivemind_anchor({ action: "delete", key: "pre_debug_state" })
// Export cycle
hivemind_cycle({ action: "export" })

// In src/hooks/event-handler.ts
export const LSPDiagnosticsHook = {
  "event": async ({ event, client }) => {
    if (event.type !== "lsp.diagnostics.publish") return
    
    const diagnostics = event.data.diagnostics
    const errors = diagnostics.filter(d => d.severity === 1)
    
    if (errors.length > 0) {
      // Trigger debug orchestration
      await triggerDebugOrchestration({
        source: "lsp",
        errors,
        file: event.data.uri
      })
    }
  }
}

// In src/hooks/event-handler.ts
export const TestFailureHook = {
  "event": async ({ event }) => {
    if (event.type !== "test.failed") return
    
    // Capture test output
    const testOutput = event.data.output
    
    // Trigger debug orchestration
    await triggerDebugOrchestration({
      source: "test",
      errors: parseTestFailures(testOutput),
      testFile: event.data.file
    })
  }
}

// In commands/debug.ts
export const debugCommand = {
  name: "debug",
  description: "Trigger debug orchestration for a specific issue",
  
  async execute(args) {
    return triggerDebugOrchestration({
      source: "manual",
      issue: args.issue,
      context: args.context
    })
  }
}

┌─────────────────────────────────────────────────────────────┐
│                     EVENT DETECTED                           │
│  (LSP error / Test failure / Manual trigger)                │
└──────────────────────────┬──────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                  CONTEXT PRESERVATION                        │
│  - Snapshot state via hivemind_anchor                       │
│  - Start debug session via hivemind_session                  │
│  - Create debug boundary in memory                          │
└──────────────────────────┬──────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                  STRATEGY SELECTION                          │
│  - Reproducible? Obvious?                                   │
│  - Select: systematic / parallel / extended                 │
└──────────────────────────┬──────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                      EXECUTION                               │
│  - Inject skills                                            │
│  - Debug loop: gather → hypothesize → test → verify         │
│  - Check drift, compact if needed                           │
└──────────────────────────┬──────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                    RESOLUTION                               │
│  - Verify fix                                               │
│  - Document solution                                        │
│  - Cleanup anchors                                          │
│  - Export cycle                                             │
└─────────────────────────────────────────────────────────────┘