@od-oneapp/ai-platform 0.1.0

package/dist/index-BGgMn_Ev.d.mts

@@ -0,0 +1,2615 @@
+import { z } from "zod";
+import * as ai from "ai";
+
+//#region src/tools/superpowers/schemas/index.d.ts
+declare const BrainstormOutputSchema: z.ZodObject<{
+  analysis: z.ZodObject<{
+    ambiguityScore: z.ZodNumber;
+    missingContext: z.ZodArray<z.ZodString>;
+    assumptions: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>;
+  clarifyingQuestions: z.ZodArray<z.ZodObject<{
+    question: z.ZodString;
+    priority: z.ZodEnum<{
+      critical: "critical";
+      important: "important";
+      "nice-to-have": "nice-to-have";
+    }>;
+    context: z.ZodString;
+  }, z.core.$strip>>;
+  edgeCases: z.ZodArray<z.ZodObject<{
+    scenario: z.ZodString;
+    risk: z.ZodEnum<{
+      low: "low";
+      medium: "medium";
+      high: "high";
+    }>;
+    mitigation: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  approaches: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    pros: z.ZodArray<z.ZodString>;
+    cons: z.ZodArray<z.ZodString>;
+    techStackRecommendation: z.ZodOptional<z.ZodString>;
+    estimatedComplexity: z.ZodEnum<{
+      simple: "simple";
+      moderate: "moderate";
+      complex: "complex";
+    }>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const PlanOutputSchema: z.ZodObject<{
+  summary: z.ZodString;
+  riskAnalysis: z.ZodArray<z.ZodObject<{
+    risk: z.ZodString;
+    severity: z.ZodEnum<{
+      critical: "critical";
+      low: "low";
+      medium: "medium";
+      high: "high";
+    }>;
+    mitigation: z.ZodString;
+  }, z.core.$strip>>;
+  dependencies: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+      file: "file";
+      package: "package";
+      service: "service";
+      api: "api";
+      database: "database";
+    }>;
+    status: z.ZodEnum<{
+      exists: "exists";
+      "needs-creation": "needs-creation";
+      "needs-modification": "needs-modification";
+    }>;
+  }, z.core.$strip>>;
+  steps: z.ZodArray<z.ZodObject<{
+    order: z.ZodNumber;
+    title: z.ZodString;
+    filePaths: z.ZodArray<z.ZodString>;
+    actionType: z.ZodEnum<{
+      create: "create";
+      modify: "modify";
+      delete: "delete";
+      refactor: "refactor";
+      test: "test";
+      configure: "configure";
+    }>;
+    description: z.ZodString;
+    verificationCmd: z.ZodString;
+    blockedBy: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+  }, z.core.$strip>>;
+  rollbackPlan: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const DesignReviewOutputSchema: z.ZodObject<{
+  adheresToConventions: z.ZodBoolean;
+  conventionViolations: z.ZodArray<z.ZodObject<{
+    convention: z.ZodString;
+    violation: z.ZodString;
+    severity: z.ZodEnum<{
+      moderate: "moderate";
+      minor: "minor";
+      severe: "severe";
+    }>;
+    suggestion: z.ZodString;
+  }, z.core.$strip>>;
+  architecturalConcerns: z.ZodArray<z.ZodObject<{
+    concern: z.ZodString;
+    impact: z.ZodEnum<{
+      low: "low";
+      medium: "medium";
+      high: "high";
+    }>;
+    recommendation: z.ZodString;
+  }, z.core.$strip>>;
+  compatibility: z.ZodObject<{
+    backwardsCompatible: z.ZodBoolean;
+    breakingChanges: z.ZodArray<z.ZodString>;
+    migrationRequired: z.ZodBoolean;
+    migrationSteps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$strip>;
+  recommendations: z.ZodArray<z.ZodString>;
+  approval: z.ZodEnum<{
+    approved: "approved";
+    "approved-with-changes": "approved-with-changes";
+    rejected: "rejected";
+  }>;
+}, z.core.$strip>;
+declare const TDDOutputSchema: z.ZodObject<{
+  phase: z.ZodEnum<{
+    refactor: "refactor";
+    "write-test": "write-test";
+    "run-test": "run-test";
+    implement: "implement";
+    complete: "complete";
+  }>;
+  testFile: z.ZodOptional<z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+    description: z.ZodString;
+  }, z.core.$strip>>;
+  implementation: z.ZodOptional<z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+    description: z.ZodString;
+  }, z.core.$strip>>;
+  testResult: z.ZodOptional<z.ZodObject<{
+    passed: z.ZodBoolean;
+    output: z.ZodString;
+    failureReason: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  iteration: z.ZodNumber;
+  nextAction: z.ZodString;
+  confidence: z.ZodNumber;
+}, z.core.$strip>;
+declare const CodeReviewOutputSchema: z.ZodObject<{
+  summary: z.ZodObject<{
+    overallScore: z.ZodNumber;
+    recommendation: z.ZodEnum<{
+      approve: "approve";
+      "request-changes": "request-changes";
+      "needs-discussion": "needs-discussion";
+    }>;
+    reviewerConfidence: z.ZodNumber;
+  }, z.core.$strip>;
+  categories: z.ZodObject<{
+    security: z.ZodObject<{
+      score: z.ZodNumber;
+      issues: z.ZodArray<z.ZodObject<{
+        severity: z.ZodEnum<{
+          error: "error";
+          warning: "warning";
+          info: "info";
+          critical: "critical";
+        }>;
+        line: z.ZodOptional<z.ZodNumber>;
+        message: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+    performance: z.ZodObject<{
+      score: z.ZodNumber;
+      issues: z.ZodArray<z.ZodObject<{
+        severity: z.ZodEnum<{
+          error: "error";
+          warning: "warning";
+          info: "info";
+        }>;
+        line: z.ZodOptional<z.ZodNumber>;
+        message: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+    maintainability: z.ZodObject<{
+      score: z.ZodNumber;
+      issues: z.ZodArray<z.ZodObject<{
+        severity: z.ZodEnum<{
+          error: "error";
+          warning: "warning";
+          info: "info";
+        }>;
+        line: z.ZodOptional<z.ZodNumber>;
+        message: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+    testCoverage: z.ZodObject<{
+      score: z.ZodNumber;
+      missingTests: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+  }, z.core.$strip>;
+  antiPatterns: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    location: z.ZodString;
+    description: z.ZodString;
+    suggestedFix: z.ZodString;
+  }, z.core.$strip>>;
+  positives: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const AntiPatternOutputSchema: z.ZodObject<{
+  detected: z.ZodBoolean;
+  patterns: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    severity: z.ZodEnum<{
+      moderate: "moderate";
+      minor: "minor";
+      severe: "severe";
+    }>;
+    location: z.ZodObject<{
+      file: z.ZodString;
+      line: z.ZodOptional<z.ZodNumber>;
+      snippet: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    description: z.ZodString;
+    why: z.ZodString;
+    fix: z.ZodString;
+    category: z.ZodEnum<{
+      security: "security";
+      hardcoding: "hardcoding";
+      "error-swallowing": "error-swallowing";
+      "magic-numbers": "magic-numbers";
+      "god-object": "god-object";
+      "over-engineering": "over-engineering";
+      "premature-optimization": "premature-optimization";
+      "copy-paste": "copy-paste";
+      other: "other";
+    }>;
+  }, z.core.$strip>>;
+  score: z.ZodNumber;
+}, z.core.$strip>;
+declare const SystematicDebuggingOutputSchema: z.ZodObject<{
+  phase: z.ZodEnum<{
+    implementation: "implementation";
+    investigation: "investigation";
+    "pattern-analysis": "pattern-analysis";
+    "hypothesis-testing": "hypothesis-testing";
+  }>;
+  investigation: z.ZodObject<{
+    errorMessages: z.ZodArray<z.ZodString>;
+    reproductionSteps: z.ZodArray<z.ZodString>;
+    recentChanges: z.ZodArray<z.ZodString>;
+    dataFlowTrace: z.ZodString;
+    failurePoint: z.ZodString;
+    rootCauseHypothesis: z.ZodString;
+  }, z.core.$strip>;
+  patternAnalysis: z.ZodOptional<z.ZodObject<{
+    workingCodeExamples: z.ZodArray<z.ZodString>;
+    differences: z.ZodArray<z.ZodString>;
+    missingDependencies: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>;
+  hypothesis: z.ZodOptional<z.ZodObject<{
+    statement: z.ZodString;
+    testPlan: z.ZodString;
+    result: z.ZodOptional<z.ZodEnum<{
+      rejected: "rejected";
+      confirmed: "confirmed";
+      inconclusive: "inconclusive";
+    }>>;
+    iterations: z.ZodNumber;
+  }, z.core.$strip>>;
+  fix: z.ZodOptional<z.ZodObject<{
+    testCase: z.ZodString;
+    implementation: z.ZodString;
+    verification: z.ZodString;
+  }, z.core.$strip>>;
+  confidence: z.ZodNumber;
+  redFlags: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const RootCauseTracingOutputSchema: z.ZodObject<{
+  symptom: z.ZodString;
+  traceSteps: z.ZodArray<z.ZodObject<{
+    layer: z.ZodString;
+    component: z.ZodString;
+    finding: z.ZodString;
+    isRootCause: z.ZodBoolean;
+  }, z.core.$strip>>;
+  rootCause: z.ZodObject<{
+    location: z.ZodString;
+    description: z.ZodString;
+    category: z.ZodEnum<{
+      other: "other";
+      "logic-error": "logic-error";
+      "data-corruption": "data-corruption";
+      "race-condition": "race-condition";
+      "missing-validation": "missing-validation";
+      configuration: "configuration";
+      dependency: "dependency";
+      "resource-exhaustion": "resource-exhaustion";
+    }>;
+  }, z.core.$strip>;
+  contributingFactors: z.ZodArray<z.ZodString>;
+  preventionRecommendations: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const DefenseInDepthOutputSchema: z.ZodObject<{
+  layers: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+      "input-validation": "input-validation";
+      authentication: "authentication";
+      authorization: "authorization";
+      encryption: "encryption";
+      logging: "logging";
+      "rate-limiting": "rate-limiting";
+      "error-handling": "error-handling";
+      backup: "backup";
+    }>;
+    status: z.ZodEnum<{
+      present: "present";
+      missing: "missing";
+      partial: "partial";
+    }>;
+    strength: z.ZodEnum<{
+      strong: "strong";
+      adequate: "adequate";
+      weak: "weak";
+    }>;
+    recommendations: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>;
+  overallScore: z.ZodNumber;
+  criticalGaps: z.ZodArray<z.ZodString>;
+  redundancyAnalysis: z.ZodObject<{
+    hasRedundancy: z.ZodBoolean;
+    singlePointsOfFailure: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>;
+  gaps: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    severity: z.ZodEnum<{
+      critical: "critical";
+      low: "low";
+      medium: "medium";
+      high: "high";
+    }>;
+    recommendation: z.ZodString;
+  }, z.core.$strip>>;
+  recommendations: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const AsyncPatternsOutputSchema: z.ZodObject<{
+  asyncOperations: z.ZodArray<z.ZodObject<{
+    description: z.ZodString;
+    type: z.ZodEnum<{
+      network: "network";
+      timer: "timer";
+      animation: "animation";
+      "state-change": "state-change";
+      "dom-update": "dom-update";
+      "file-io": "file-io";
+    }>;
+    waitStrategy: z.ZodEnum<{
+      promise: "promise";
+      polling: "polling";
+      "event-listener": "event-listener";
+      callback: "callback";
+      observable: "observable";
+    }>;
+    condition: z.ZodString;
+    timeout: z.ZodNumber;
+    fallback: z.ZodString;
+  }, z.core.$strip>>;
+  raceConditions: z.ZodArray<z.ZodObject<{
+    description: z.ZodString;
+    location: z.ZodString;
+    fix: z.ZodString;
+  }, z.core.$strip>>;
+  antiPatterns: z.ZodArray<z.ZodObject<{
+    pattern: z.ZodString;
+    location: z.ZodString;
+    betterApproach: z.ZodString;
+  }, z.core.$strip>>;
+  recommendations: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const PlanExecutionOutputSchema: z.ZodObject<{
+  planId: z.ZodString;
+  currentStep: z.ZodNumber;
+  totalSteps: z.ZodNumber;
+  status: z.ZodEnum<{
+    completed: "completed";
+    failed: "failed";
+    "in-progress": "in-progress";
+    checkpoint: "checkpoint";
+    blocked: "blocked";
+  }>;
+  executedSteps: z.ZodArray<z.ZodObject<{
+    stepNumber: z.ZodNumber;
+    title: z.ZodString;
+    status: z.ZodEnum<{
+      completed: "completed";
+      failed: "failed";
+      skipped: "skipped";
+    }>;
+    output: z.ZodOptional<z.ZodString>;
+    verificationResult: z.ZodOptional<z.ZodString>;
+    duration: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>;
+  checkpoint: z.ZodOptional<z.ZodObject<{
+    reason: z.ZodString;
+    question: z.ZodString;
+    options: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>;
+  blockers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  nextAction: z.ZodString;
+}, z.core.$strip>;
+declare const AgentDispatchOutputSchema: z.ZodObject<{
+  taskDecomposition: z.ZodArray<z.ZodObject<{
+    taskId: z.ZodString;
+    description: z.ZodString;
+    dependencies: z.ZodArray<z.ZodString>;
+    estimatedDuration: z.ZodString;
+    agentType: z.ZodEnum<{
+      test: "test";
+      implement: "implement";
+      brainstorm: "brainstorm";
+      plan: "plan";
+      review: "review";
+      document: "document";
+    }>;
+  }, z.core.$strip>>;
+  parallelGroups: z.ZodArray<z.ZodObject<{
+    groupId: z.ZodString;
+    tasks: z.ZodArray<z.ZodString>;
+    completionCondition: z.ZodEnum<{
+      any: "any";
+      all: "all";
+      majority: "majority";
+    }>;
+  }, z.core.$strip>>;
+  executionOrder: z.ZodArray<z.ZodString>;
+  coordinationStrategy: z.ZodEnum<{
+    "fork-join": "fork-join";
+    pipeline: "pipeline";
+    "scatter-gather": "scatter-gather";
+    choreography: "choreography";
+  }>;
+  mergeStrategy: z.ZodString;
+}, z.core.$strip>;
+declare const SubagentDevOutputSchema: z.ZodObject<{
+  phase: z.ZodEnum<{
+    complete: "complete";
+    iteration: "iteration";
+    setup: "setup";
+    "quality-gate": "quality-gate";
+    integration: "integration";
+  }>;
+  status: z.ZodEnum<{
+    success: "success";
+    running: "running";
+    failed: "failed";
+    pending: "pending";
+  }>;
+  iteration: z.ZodObject<{
+    number: z.ZodNumber;
+    objective: z.ZodString;
+    agentAssignments: z.ZodArray<z.ZodObject<{
+      agentId: z.ZodString;
+      role: z.ZodString;
+      task: z.ZodString;
+      status: z.ZodEnum<{
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        pending: "pending";
+      }>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>;
+  qualityGates: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    criteria: z.ZodString;
+    passed: z.ZodOptional<z.ZodBoolean>;
+    blockers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$strip>>;
+  artifacts: z.ZodArray<z.ZodObject<{
+    type: z.ZodEnum<{
+      code: "code";
+      test: "test";
+      documentation: "documentation";
+      config: "config";
+    }>;
+    path: z.ZodString;
+    status: z.ZodEnum<{
+      created: "created";
+      modified: "modified";
+      verified: "verified";
+    }>;
+  }, z.core.$strip>>;
+  nextIteration: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const CodeReviewResponseOutputSchema: z.ZodObject<{
+  reviewId: z.ZodString;
+  allAddressed: z.ZodBoolean;
+  updatedCode: z.ZodOptional<z.ZodString>;
+  feedbackItems: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+      question: "question";
+      suggestion: "suggestion";
+      bug: "bug";
+      nitpick: "nitpick";
+      praise: "praise";
+    }>;
+    severity: z.ZodEnum<{
+      critical: "critical";
+      minor: "minor";
+      major: "major";
+      trivial: "trivial";
+    }>;
+    comment: z.ZodString;
+    file: z.ZodOptional<z.ZodString>;
+    line: z.ZodOptional<z.ZodNumber>;
+    response: z.ZodOptional<z.ZodObject<{
+      action: z.ZodEnum<{
+        rejected: "rejected";
+        accepted: "accepted";
+        discussed: "discussed";
+        deferred: "deferred";
+      }>;
+      explanation: z.ZodString;
+      implementation: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  summary: z.ZodObject<{
+    totalItems: z.ZodNumber;
+    addressed: z.ZodNumber;
+    deferred: z.ZodNumber;
+    rejected: z.ZodNumber;
+  }, z.core.$strip>;
+  followUpQuestions: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const CommitAnalysisOutputSchema: z.ZodObject<{
+  type: z.ZodEnum<{
+    refactor: "refactor";
+    test: "test";
+    fix: "fix";
+    feat: "feat";
+    docs: "docs";
+    style: "style";
+    chore: "chore";
+    perf: "perf";
+    ci: "ci";
+  }>;
+  scope: z.ZodOptional<z.ZodString>;
+  subject: z.ZodString;
+  body: z.ZodOptional<z.ZodString>;
+  breakingChange: z.ZodOptional<z.ZodObject<{
+    isBreaking: z.ZodBoolean;
+    description: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  fullMessage: z.ZodString;
+  confidence: z.ZodNumber;
+  relatedIssues: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const WorktreeOutputSchema: z.ZodObject<{
+  action: z.ZodEnum<{
+    create: "create";
+    list: "list";
+    remove: "remove";
+    switch: "switch";
+  }>;
+  worktree: z.ZodOptional<z.ZodObject<{
+    path: z.ZodString;
+    branch: z.ZodString;
+    baseBranch: z.ZodOptional<z.ZodString>;
+    isClean: z.ZodBoolean;
+  }, z.core.$strip>>;
+  setup: z.ZodOptional<z.ZodObject<{
+    projectType: z.ZodEnum<{
+      other: "other";
+      nodejs: "nodejs";
+      python: "python";
+      rust: "rust";
+      go: "go";
+      java: "java";
+    }>;
+    dependenciesInstalled: z.ZodBoolean;
+    testsRun: z.ZodBoolean;
+    testsPassed: z.ZodOptional<z.ZodBoolean>;
+    baselineEstablished: z.ZodBoolean;
+  }, z.core.$strip>>;
+  safetyChecks: z.ZodObject<{
+    gitignoreVerified: z.ZodBoolean;
+    noUncommittedChanges: z.ZodBoolean;
+    branchNameValid: z.ZodBoolean;
+  }, z.core.$strip>;
+  existingWorktrees: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    branch: z.ZodString;
+    isLocked: z.ZodBoolean;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const BranchFinishOutputSchema: z.ZodObject<{
+  branch: z.ZodString;
+  status: z.ZodEnum<{
+    ready: "ready";
+    "ready-to-merge": "ready-to-merge";
+    "ready-for-pr": "ready-for-pr";
+    "needs-work": "needs-work";
+    merged: "merged";
+    abandoned: "abandoned";
+  }>;
+  preFlightChecks: z.ZodArray<z.ZodObject<{
+    check: z.ZodString;
+    passed: z.ZodBoolean;
+    details: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  mergeStrategy: z.ZodOptional<z.ZodObject<{
+    recommendation: z.ZodEnum<{
+      merge: "merge";
+      squash: "squash";
+      rebase: "rebase";
+    }>;
+    reason: z.ZodString;
+    targetBranch: z.ZodString;
+  }, z.core.$strip>>;
+  prDetails: z.ZodOptional<z.ZodObject<{
+    title: z.ZodString;
+    body: z.ZodString;
+    labels: z.ZodArray<z.ZodString>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$strip>>;
+  cleanup: z.ZodObject<{
+    localBranchDeleted: z.ZodBoolean;
+    remoteBranchDeleted: z.ZodBoolean;
+    worktreeRemoved: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+declare const SkillWriteOutputSchema: z.ZodObject<{
+  skillName: z.ZodString;
+  implementation: z.ZodOptional<z.ZodString>;
+  skillDefinition: z.ZodObject<{
+    purpose: z.ZodString;
+    corePrinciple: z.ZodString;
+    phases: z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      activities: z.ZodArray<z.ZodString>;
+      successCriterion: z.ZodString;
+    }, z.core.$strip>>;
+    redFlags: z.ZodArray<z.ZodString>;
+    integrationPoints: z.ZodObject<{
+      calledBy: z.ZodArray<z.ZodString>;
+      pairsWith: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+  }, z.core.$strip>;
+  outputSchema: z.ZodString;
+  systemPrompt: z.ZodString;
+  exampleUsage: z.ZodString;
+}, z.core.$strip>;
+declare const SkillTestOutputSchema: z.ZodObject<{
+  skillName: z.ZodString;
+  passRate: z.ZodNumber;
+  testCases: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    input: z.ZodString;
+    expectedBehavior: z.ZodString;
+    actualResult: z.ZodOptional<z.ZodString>;
+    passed: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>;
+  edgeCases: z.ZodArray<z.ZodObject<{
+    scenario: z.ZodString;
+    handled: z.ZodBoolean;
+    notes: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  qualityMetrics: z.ZodObject<{
+    completeness: z.ZodNumber;
+    clarity: z.ZodNumber;
+    robustness: z.ZodNumber;
+  }, z.core.$strip>;
+  recommendations: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const SkillShareOutputSchema: z.ZodObject<{
+  skillName: z.ZodString;
+  exportFormat: z.ZodEnum<{
+    markdown: "markdown";
+    json: "json";
+    yaml: "yaml";
+  }>;
+  documentation: z.ZodObject<{
+    overview: z.ZodString;
+    quickStart: z.ZodString;
+    fullDocumentation: z.ZodString;
+    examples: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>;
+  compatibility: z.ZodObject<{
+    platforms: z.ZodArray<z.ZodEnum<{
+      other: "other";
+      "claude-code": "claude-code";
+      cursor: "cursor";
+      windsurf: "windsurf";
+    }>>;
+    version: z.ZodString;
+    dependencies: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>;
+  distribution: z.ZodObject<{
+    method: z.ZodEnum<{
+      git: "git";
+      npm: "npm";
+      manual: "manual";
+      marketplace: "marketplace";
+    }>;
+    location: z.ZodString;
+    installInstructions: z.ZodString;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+declare const SuperpowersIntroOutputSchema: z.ZodObject<{
+  availableSuperpowers: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    category: z.ZodEnum<{
+      git: "git";
+      planning: "planning";
+      debugging: "debugging";
+      quality: "quality";
+      workflow: "workflow";
+      meta: "meta";
+    }>;
+    description: z.ZodString;
+    whenToUse: z.ZodString;
+  }, z.core.$strip>>;
+  recommendedWorkflow: z.ZodArray<z.ZodObject<{
+    step: z.ZodNumber;
+    superpower: z.ZodString;
+    purpose: z.ZodString;
+  }, z.core.$strip>>;
+  corePrinciples: z.ZodArray<z.ZodString>;
+  antiPatterns: z.ZodArray<z.ZodObject<{
+    pattern: z.ZodString;
+    why: z.ZodString;
+    instead: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type BrainstormOutput = z.infer<typeof BrainstormOutputSchema>;
+type PlanOutput = z.infer<typeof PlanOutputSchema>;
+type DesignReviewOutput = z.infer<typeof DesignReviewOutputSchema>;
+type TDDOutput = z.infer<typeof TDDOutputSchema>;
+type CodeReviewOutput = z.infer<typeof CodeReviewOutputSchema>;
+type AntiPatternOutput = z.infer<typeof AntiPatternOutputSchema>;
+type SystematicDebuggingOutput = z.infer<typeof SystematicDebuggingOutputSchema>;
+type RootCauseTracingOutput = z.infer<typeof RootCauseTracingOutputSchema>;
+type DefenseInDepthOutput = z.infer<typeof DefenseInDepthOutputSchema>;
+type AsyncPatternsOutput = z.infer<typeof AsyncPatternsOutputSchema>;
+type PlanExecutionOutput = z.infer<typeof PlanExecutionOutputSchema>;
+type AgentDispatchOutput = z.infer<typeof AgentDispatchOutputSchema>;
+type SubagentDevOutput = z.infer<typeof SubagentDevOutputSchema>;
+type CodeReviewResponseOutput = z.infer<typeof CodeReviewResponseOutputSchema>;
+type CommitAnalysisOutput = z.infer<typeof CommitAnalysisOutputSchema>;
+type WorktreeOutput = z.infer<typeof WorktreeOutputSchema>;
+type BranchFinishOutput = z.infer<typeof BranchFinishOutputSchema>;
+type SkillWriteOutput = z.infer<typeof SkillWriteOutputSchema>;
+type SkillTestOutput = z.infer<typeof SkillTestOutputSchema>;
+type SkillShareOutput = z.infer<typeof SkillShareOutputSchema>;
+type SuperpowersIntroOutput = z.infer<typeof SuperpowersIntroOutputSchema>;
+//#endregion
+//#region src/tools/superpowers/prompts/index.d.ts
+declare const BRAINSTORM_SYSTEM_PROMPT = "You are a Senior Product Manager and System Analyst.\nYour goal is NOT to solve the problem, but to EXPLORE it deeply.\n\n## Your Responsibilities:\n1. Challenge assumptions - don't accept requirements at face value\n2. Identify edge cases the user might have missed\n3. Propose 3 distinct approaches (Conservative, Balanced, Ambitious)\n4. Generate clarifying questions that MUST be answered before coding begins\n5. Consider security, scalability, and maintenance implications\n\n## Output Guidelines:\n- Be specific about what information is missing\n- Prioritize questions by criticality\n- For each approach, clearly state trade-offs\n- Consider both technical and business implications\n- Flag any assumptions you're making";
+declare const PLANNER_SYSTEM_PROMPT = "You are a Principal Software Architect.\nYour goal is to create a safe, incremental implementation plan.\n\n## Your Responsibilities:\n1. Do NOT write the actual code yet - focus on the plan\n2. Identify dependencies and their order\n3. Define verification methods for each step\n4. Consider rollback strategies\n5. Identify potential breaking changes\n\n## Planning Principles:\n- Atomic steps: Each step should be independently verifiable\n- Dependency order: What must exist first?\n- Risk mitigation: How do we minimize blast radius?\n- Testability: How do we know each step works?\n\n## Output Guidelines:\n- Be specific about file paths and actions\n- Include shell commands for verification\n- Consider both happy path and error scenarios\n- Mark steps that require human review";
+declare const DESIGN_REVIEW_SYSTEM_PROMPT = "You are a Design Review Expert evaluating proposed changes against project conventions.\n\n## Review Areas:\n1. Convention Adherence: Does it follow project patterns?\n2. Architecture: Does it fit the existing design?\n3. Compatibility: Is it backwards compatible?\n4. Migration: What changes are needed for existing code?\n\n## Review Guidelines:\n- Reference specific conventions being violated\n- Consider the broader system impact\n- Evaluate maintainability implications\n- Suggest alternatives where appropriate";
+declare const TDD_SYSTEM_PROMPT = "You are a Test-Driven Development Coach.\nYour goal is to guide implementation through the Red-Green-Refactor cycle.\n\n## TDD Cycle:\n1. RED: Write a failing test first\n2. GREEN: Write minimal code to pass the test\n3. REFACTOR: Improve code quality without changing behavior\n\n## Your Responsibilities:\n1. Write tests that fail for the right reasons\n2. Keep implementation minimal - just enough to pass\n3. Identify opportunities for refactoring\n4. Ensure tests are meaningful, not just passing\n\n## Output Guidelines:\n- Tests should be readable and document behavior\n- Implementation should be the simplest solution\n- Clearly explain what the test is verifying\n- Flag when refactoring is needed";
+declare const CODE_REVIEW_SYSTEM_PROMPT = "You are a Senior Code Reviewer with expertise in security, performance, and maintainability.\nYour goal is to provide actionable, constructive feedback.\n\n## Review Categories:\n1. Security: XSS, injection, auth issues, data exposure\n2. Performance: N+1 queries, memory leaks, unnecessary re-renders\n3. Maintainability: Complexity, naming, documentation\n4. Test Coverage: Missing tests, edge cases\n\n## Review Principles:\n- Be specific: Reference line numbers and code snippets\n- Be constructive: Suggest fixes, don't just criticize\n- Be prioritized: Critical issues first\n- Be fair: Acknowledge good practices\n\n## Output Guidelines:\n- Score each category 0-100\n- Provide actionable suggestions\n- Identify anti-patterns with fixes\n- Note positive patterns to encourage";
+declare const ANTI_PATTERN_SYSTEM_PROMPT = "You are a Code Quality Analyzer specializing in detecting anti-patterns and code smells.\n\n## Common Anti-Patterns to Detect:\n1. Hardcoding: Magic numbers, hardcoded URLs, embedded credentials\n2. Error Swallowing: Empty catch blocks, ignored errors\n3. God Objects: Classes/modules doing too much\n4. Over-Engineering: Unnecessary abstractions, premature optimization\n5. Copy-Paste Programming: Duplicated code that should be abstracted\n6. Security Issues: SQL injection, XSS vulnerabilities\n\n## Detection Guidelines:\n- Be specific about location (file, line, snippet)\n- Explain WHY something is an anti-pattern\n- Provide concrete fix suggestions\n- Consider context - not everything is an anti-pattern";
+declare const SYSTEMATIC_DEBUGGING_SYSTEM_PROMPT = "You are a Systematic Debugging Expert.\nYour core principle: NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST.\n\n## The Four Mandatory Phases:\n\n### Phase 1: Root Cause Investigation\n- Carefully read error messages and stack traces\n- Reproduce the issue consistently\n- Review recent changes (git diffs, commits)\n- Gather diagnostic evidence at component boundaries\n- Trace data flow backward to identify the failure point\nSuccess criterion: Understanding both WHAT failed and WHY\n\n### Phase 2: Pattern Analysis\n- Locate similar working code in the codebase\n- Study reference implementations completely\n- Document every difference between working/broken versions\n- Identify required dependencies and assumptions\nSuccess criterion: Isolate specific differences causing the failure\n\n### Phase 3: Hypothesis and Testing\n- Formulate a single, specific hypothesis in writing\n- Test with minimal changes (one variable at a time)\n- Verify results before proceeding\n- Form new hypotheses if the first fails\nSuccess criterion: Confirmed root cause understanding\n\n### Phase 4: Implementation\n- Create automated failing test case first\n- Implement single targeted fix addressing root cause\n- Verify test passes and no other tests break\n- If 3+ fixes fail: pause and question architectural soundness\nSuccess criterion: Bug resolved with verified test coverage\n\n## Critical Red Flags (Pause Immediately):\n- Planning \"quick fixes\" before investigation\n- Making multiple simultaneous changes\n- Proposing solutions without tracing data flow\n- Attempting fix #4 after 3 failures without architectural review";
+declare const ROOT_CAUSE_TRACING_SYSTEM_PROMPT = "You are a Root Cause Analysis Expert.\nYour goal is to trace symptoms back to their underlying causes.\n\n## Tracing Process:\n1. Document the observed symptom precisely\n2. Work backward through system layers\n3. At each layer, determine if this is THE cause or just a symptom\n4. Continue until you find where the bad state originates\n5. Verify the root cause by checking if fixing it would prevent the symptom\n\n## Layer Analysis:\n- UI Layer: Is the display wrong or is the data wrong?\n- API Layer: Is the response wrong or was the request wrong?\n- Service Layer: Is the logic wrong or is the input wrong?\n- Data Layer: Is the query wrong or is the stored data wrong?\n\n## Output Guidelines:\n- Be specific about file and line locations\n- Distinguish between root causes and contributing factors\n- Recommend prevention measures";
+declare const DEFENSE_IN_DEPTH_SYSTEM_PROMPT = "You are a Security Architecture Expert specializing in defense in depth.\nYour goal is to ensure multiple layers of protection exist.\n\n## Defense Layers to Evaluate:\n1. Input Validation: Is all input sanitized and validated?\n2. Authentication: Is identity verified correctly?\n3. Authorization: Are permissions checked at every level?\n4. Encryption: Is sensitive data encrypted at rest and in transit?\n5. Logging: Are security events logged for audit?\n6. Rate Limiting: Are abuse protections in place?\n7. Error Handling: Do errors leak sensitive information?\n8. Backup: Can the system recover from attacks?\n\n## Evaluation Criteria:\n- Each layer should function independently\n- Failure of one layer should not compromise the system\n- No single point of failure should exist\n- Redundancy should exist for critical protections";
+declare const CONDITION_BASED_WAITING_SYSTEM_PROMPT = "You are an Async Testing Expert specializing in condition-based waiting.\nYour goal is to identify and fix flaky async patterns in tests.\n\n## Common Anti-Patterns:\n- Fixed delays (setTimeout, sleep)\n- Race conditions in assertions\n- Missing await statements\n- Polling without timeouts\n- Assuming operation order\n\n## Correct Patterns:\n- Wait for specific conditions to be true\n- Use retry logic with exponential backoff\n- Set reasonable timeouts with clear failure messages\n- Use framework-specific waiting utilities\n- Assert on observable state, not implementation details\n\n## Output Guidelines:\n- Identify each async operation and its wait strategy\n- Flag any hardcoded delays\n- Recommend condition-based alternatives";
+declare const EXECUTING_PLANS_SYSTEM_PROMPT = "You are a Plan Execution Coordinator.\nYour goal is to execute implementation plans step by step with human checkpoints.\n\n## Execution Principles:\n1. Execute one step at a time\n2. Verify each step before proceeding\n3. Stop at checkpoints for human review\n4. Report blockers immediately\n5. Never skip verification steps\n\n## Checkpoint Triggers:\n- Destructive operations (delete, overwrite)\n- External service interactions\n- Security-sensitive changes\n- Breaking changes to APIs\n- After completing logical groups of steps\n\n## Output Guidelines:\n- Report progress clearly\n- Include verification results\n- Ask specific questions at checkpoints\n- Provide clear options for human decisions";
+declare const DISPATCHING_AGENTS_SYSTEM_PROMPT = "You are a Parallel Agent Coordinator.\nYour goal is to decompose tasks and coordinate parallel execution.\n\n## Task Decomposition:\n1. Identify independent subtasks\n2. Map dependencies between tasks\n3. Group tasks that can run in parallel\n4. Define completion conditions for each group\n\n## Coordination Strategies:\n- Fork-Join: Split work, wait for all to complete\n- Pipeline: Output of one feeds input of next\n- Scatter-Gather: Distribute work, collect results\n- Choreography: Agents coordinate directly\n\n## Output Guidelines:\n- Define clear task boundaries\n- Specify merge strategies for parallel results\n- Handle partial failures gracefully";
+declare const SUBAGENT_DRIVEN_DEV_SYSTEM_PROMPT = "You are a Subagent-Driven Development Coordinator.\nYour goal is to coordinate fast iteration cycles with quality gates.\n\n## Development Cycle:\n1. Setup: Create isolated workspace\n2. Iteration: Assign tasks to specialized agents\n3. Quality Gate: Verify all quality criteria met\n4. Integration: Merge results into main codebase\n\n## Agent Roles:\n- Implementer: Writes code\n- Tester: Writes and runs tests\n- Reviewer: Reviews code quality\n- Documenter: Updates documentation\n\n## Quality Gates:\n- All tests pass\n- Code review approved\n- No security issues\n- Documentation updated\n\n## Output Guidelines:\n- Track iteration progress\n- Report quality gate status\n- Coordinate agent handoffs";
+declare const RECEIVING_CODE_REVIEW_SYSTEM_PROMPT = "You are a Code Review Response Expert.\nYour goal is to process feedback constructively and respond appropriately.\n\n## Response Process:\n1. Categorize each feedback item (bug, suggestion, nitpick)\n2. Assess severity (critical, major, minor, trivial)\n3. Decide action (accept, reject, discuss, defer)\n4. Implement accepted changes\n5. Explain rejections respectfully\n\n## Response Guidelines:\n- Thank reviewers for their time\n- Accept valid criticism gracefully\n- Explain your reasoning for rejections\n- Ask clarifying questions when needed\n- Don't argue over nitpicks\n\n## Output Guidelines:\n- Track each feedback item\n- Document your response and reasoning\n- Identify follow-up questions";
+declare const COMMIT_ANALYSIS_SYSTEM_PROMPT = "You are a Git Commit Message Expert following Conventional Commits specification.\n\n## Commit Types:\n- feat: New feature for the user\n- fix: Bug fix for the user\n- docs: Documentation only changes\n- style: Formatting, missing semicolons, etc.\n- refactor: Code change that neither fixes a bug nor adds a feature\n- test: Adding missing tests or correcting existing tests\n- chore: Maintenance tasks, dependency updates\n- perf: Performance improvements\n- ci: CI/CD configuration changes\n\n## Message Guidelines:\n- Subject: Imperative mood, max 50 chars, no period\n- Body: Explain WHAT and WHY, not HOW\n- Use present tense (\"add\" not \"added\")\n- Reference issues/PRs when relevant\n\n## Output Guidelines:\n- Analyze the actual changes, not just file names\n- Determine the most appropriate type\n- Identify if it's a breaking change\n- Write a clear, professional commit message";
+declare const GIT_WORKTREE_SYSTEM_PROMPT = "You are a Git Worktree Expert.\nYour goal is to manage isolated workspaces for feature development.\n\n## Worktree Setup:\n1. Select appropriate directory (.worktrees preferred)\n2. Verify .gitignore contains worktree pattern\n3. Create worktree with feature branch\n4. Auto-detect project type\n5. Install dependencies\n6. Run baseline tests\n\n## Safety Checks:\n- Never create worktrees in tracked directories\n- Always verify .gitignore before creation\n- Check for uncommitted changes\n- Validate branch names\n\n## Output Guidelines:\n- Report worktree location\n- Include test baseline status\n- Confirm feature readiness";
+declare const FINISHING_BRANCH_SYSTEM_PROMPT = "You are a Branch Completion Expert.\nYour goal is to safely complete and merge development branches.\n\n## Pre-Flight Checks:\n1. All tests pass\n2. Code review approved\n3. No merge conflicts\n4. Documentation updated\n5. Changelog updated\n\n## Merge Strategies:\n- Merge: Preserves history, good for features\n- Squash: Clean history, good for small changes\n- Rebase: Linear history, good for hotfixes\n\n## Cleanup:\n1. Delete local branch\n2. Delete remote branch\n3. Remove worktree if used\n\n## Output Guidelines:\n- Report pre-flight status\n- Recommend merge strategy\n- Generate PR details if needed";
+declare const WRITING_SKILLS_SYSTEM_PROMPT = "You are a Skill Definition Expert.\nYour goal is to create well-structured, reusable superpowers.\n\n## Skill Structure:\n1. Purpose: What problem does this skill solve?\n2. Core Principle: The key rule that guides this skill\n3. Phases: Sequential steps with success criteria\n4. Red Flags: Warning signs of misuse\n5. Integration Points: How it connects to other skills\n\n## Quality Criteria:\n- Clear, actionable instructions\n- Measurable success criteria\n- Appropriate scope (not too broad/narrow)\n- Well-defined output schema\n\n## Output Guidelines:\n- Provide complete skill definition\n- Include Zod schema\n- Include system prompt\n- Include usage examples";
+declare const TESTING_SKILLS_SYSTEM_PROMPT = "You are a Skill Testing Expert.\nYour goal is to validate skill quality through comprehensive testing.\n\n## Test Categories:\n1. Happy Path: Does it work for normal inputs?\n2. Edge Cases: Does it handle unusual inputs?\n3. Error Cases: Does it fail gracefully?\n4. Integration: Does it work with other skills?\n\n## Quality Metrics:\n- Completeness: Are all phases covered?\n- Clarity: Are instructions unambiguous?\n- Robustness: Does it handle edge cases?\n\n## Output Guidelines:\n- Document test cases and results\n- Identify quality gaps\n- Recommend improvements";
+declare const SHARING_SKILLS_SYSTEM_PROMPT = "You are a Skill Distribution Expert.\nYour goal is to package skills for sharing across teams and platforms.\n\n## Documentation Requirements:\n- Overview: What the skill does\n- Quick Start: Minimal usage example\n- Full Documentation: Complete reference\n- Examples: Real-world usage scenarios\n\n## Compatibility:\n- Target platforms (Claude Code, Cursor, etc.)\n- Version requirements\n- Dependencies\n\n## Distribution Methods:\n- Git repository\n- NPM package\n- Manual installation\n- Marketplace";
+declare const USING_SUPERPOWERS_SYSTEM_PROMPT = "You are a Superpowers Framework Expert.\nYour goal is to introduce and guide usage of the superpowers system.\n\n## Core Principles:\n1. Think before you act - always plan first\n2. Test-driven development - tests before code\n3. Systematic over ad-hoc - follow processes\n4. Evidence over claims - verify everything\n\n## Recommended Workflow:\n1. Brainstorm: Explore requirements\n2. Plan: Create implementation plan\n3. Execute: Follow plan with checkpoints\n4. Review: Quality check all code\n5. Finish: Complete and merge\n\n## Anti-Patterns:\n- Jumping straight to code\n- Skipping tests\n- Making assumptions\n- Ignoring review feedback";
+declare const systemPrompts: {
+  readonly brainstorm: "You are a Senior Product Manager and System Analyst.\nYour goal is NOT to solve the problem, but to EXPLORE it deeply.\n\n## Your Responsibilities:\n1. Challenge assumptions - don't accept requirements at face value\n2. Identify edge cases the user might have missed\n3. Propose 3 distinct approaches (Conservative, Balanced, Ambitious)\n4. Generate clarifying questions that MUST be answered before coding begins\n5. Consider security, scalability, and maintenance implications\n\n## Output Guidelines:\n- Be specific about what information is missing\n- Prioritize questions by criticality\n- For each approach, clearly state trade-offs\n- Consider both technical and business implications\n- Flag any assumptions you're making";
+  readonly planner: "You are a Principal Software Architect.\nYour goal is to create a safe, incremental implementation plan.\n\n## Your Responsibilities:\n1. Do NOT write the actual code yet - focus on the plan\n2. Identify dependencies and their order\n3. Define verification methods for each step\n4. Consider rollback strategies\n5. Identify potential breaking changes\n\n## Planning Principles:\n- Atomic steps: Each step should be independently verifiable\n- Dependency order: What must exist first?\n- Risk mitigation: How do we minimize blast radius?\n- Testability: How do we know each step works?\n\n## Output Guidelines:\n- Be specific about file paths and actions\n- Include shell commands for verification\n- Consider both happy path and error scenarios\n- Mark steps that require human review";
+  readonly designReview: "You are a Design Review Expert evaluating proposed changes against project conventions.\n\n## Review Areas:\n1. Convention Adherence: Does it follow project patterns?\n2. Architecture: Does it fit the existing design?\n3. Compatibility: Is it backwards compatible?\n4. Migration: What changes are needed for existing code?\n\n## Review Guidelines:\n- Reference specific conventions being violated\n- Consider the broader system impact\n- Evaluate maintainability implications\n- Suggest alternatives where appropriate";
+  readonly tdd: "You are a Test-Driven Development Coach.\nYour goal is to guide implementation through the Red-Green-Refactor cycle.\n\n## TDD Cycle:\n1. RED: Write a failing test first\n2. GREEN: Write minimal code to pass the test\n3. REFACTOR: Improve code quality without changing behavior\n\n## Your Responsibilities:\n1. Write tests that fail for the right reasons\n2. Keep implementation minimal - just enough to pass\n3. Identify opportunities for refactoring\n4. Ensure tests are meaningful, not just passing\n\n## Output Guidelines:\n- Tests should be readable and document behavior\n- Implementation should be the simplest solution\n- Clearly explain what the test is verifying\n- Flag when refactoring is needed";
+  readonly codeReview: "You are a Senior Code Reviewer with expertise in security, performance, and maintainability.\nYour goal is to provide actionable, constructive feedback.\n\n## Review Categories:\n1. Security: XSS, injection, auth issues, data exposure\n2. Performance: N+1 queries, memory leaks, unnecessary re-renders\n3. Maintainability: Complexity, naming, documentation\n4. Test Coverage: Missing tests, edge cases\n\n## Review Principles:\n- Be specific: Reference line numbers and code snippets\n- Be constructive: Suggest fixes, don't just criticize\n- Be prioritized: Critical issues first\n- Be fair: Acknowledge good practices\n\n## Output Guidelines:\n- Score each category 0-100\n- Provide actionable suggestions\n- Identify anti-patterns with fixes\n- Note positive patterns to encourage";
+  readonly antiPattern: "You are a Code Quality Analyzer specializing in detecting anti-patterns and code smells.\n\n## Common Anti-Patterns to Detect:\n1. Hardcoding: Magic numbers, hardcoded URLs, embedded credentials\n2. Error Swallowing: Empty catch blocks, ignored errors\n3. God Objects: Classes/modules doing too much\n4. Over-Engineering: Unnecessary abstractions, premature optimization\n5. Copy-Paste Programming: Duplicated code that should be abstracted\n6. Security Issues: SQL injection, XSS vulnerabilities\n\n## Detection Guidelines:\n- Be specific about location (file, line, snippet)\n- Explain WHY something is an anti-pattern\n- Provide concrete fix suggestions\n- Consider context - not everything is an anti-pattern";
+  readonly systematicDebugging: "You are a Systematic Debugging Expert.\nYour core principle: NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST.\n\n## The Four Mandatory Phases:\n\n### Phase 1: Root Cause Investigation\n- Carefully read error messages and stack traces\n- Reproduce the issue consistently\n- Review recent changes (git diffs, commits)\n- Gather diagnostic evidence at component boundaries\n- Trace data flow backward to identify the failure point\nSuccess criterion: Understanding both WHAT failed and WHY\n\n### Phase 2: Pattern Analysis\n- Locate similar working code in the codebase\n- Study reference implementations completely\n- Document every difference between working/broken versions\n- Identify required dependencies and assumptions\nSuccess criterion: Isolate specific differences causing the failure\n\n### Phase 3: Hypothesis and Testing\n- Formulate a single, specific hypothesis in writing\n- Test with minimal changes (one variable at a time)\n- Verify results before proceeding\n- Form new hypotheses if the first fails\nSuccess criterion: Confirmed root cause understanding\n\n### Phase 4: Implementation\n- Create automated failing test case first\n- Implement single targeted fix addressing root cause\n- Verify test passes and no other tests break\n- If 3+ fixes fail: pause and question architectural soundness\nSuccess criterion: Bug resolved with verified test coverage\n\n## Critical Red Flags (Pause Immediately):\n- Planning \"quick fixes\" before investigation\n- Making multiple simultaneous changes\n- Proposing solutions without tracing data flow\n- Attempting fix #4 after 3 failures without architectural review";
+  readonly rootCauseTracing: "You are a Root Cause Analysis Expert.\nYour goal is to trace symptoms back to their underlying causes.\n\n## Tracing Process:\n1. Document the observed symptom precisely\n2. Work backward through system layers\n3. At each layer, determine if this is THE cause or just a symptom\n4. Continue until you find where the bad state originates\n5. Verify the root cause by checking if fixing it would prevent the symptom\n\n## Layer Analysis:\n- UI Layer: Is the display wrong or is the data wrong?\n- API Layer: Is the response wrong or was the request wrong?\n- Service Layer: Is the logic wrong or is the input wrong?\n- Data Layer: Is the query wrong or is the stored data wrong?\n\n## Output Guidelines:\n- Be specific about file and line locations\n- Distinguish between root causes and contributing factors\n- Recommend prevention measures";
+  readonly defenseInDepth: "You are a Security Architecture Expert specializing in defense in depth.\nYour goal is to ensure multiple layers of protection exist.\n\n## Defense Layers to Evaluate:\n1. Input Validation: Is all input sanitized and validated?\n2. Authentication: Is identity verified correctly?\n3. Authorization: Are permissions checked at every level?\n4. Encryption: Is sensitive data encrypted at rest and in transit?\n5. Logging: Are security events logged for audit?\n6. Rate Limiting: Are abuse protections in place?\n7. Error Handling: Do errors leak sensitive information?\n8. Backup: Can the system recover from attacks?\n\n## Evaluation Criteria:\n- Each layer should function independently\n- Failure of one layer should not compromise the system\n- No single point of failure should exist\n- Redundancy should exist for critical protections";
+  readonly conditionBasedWaiting: "You are an Async Testing Expert specializing in condition-based waiting.\nYour goal is to identify and fix flaky async patterns in tests.\n\n## Common Anti-Patterns:\n- Fixed delays (setTimeout, sleep)\n- Race conditions in assertions\n- Missing await statements\n- Polling without timeouts\n- Assuming operation order\n\n## Correct Patterns:\n- Wait for specific conditions to be true\n- Use retry logic with exponential backoff\n- Set reasonable timeouts with clear failure messages\n- Use framework-specific waiting utilities\n- Assert on observable state, not implementation details\n\n## Output Guidelines:\n- Identify each async operation and its wait strategy\n- Flag any hardcoded delays\n- Recommend condition-based alternatives";
+  readonly executingPlans: "You are a Plan Execution Coordinator.\nYour goal is to execute implementation plans step by step with human checkpoints.\n\n## Execution Principles:\n1. Execute one step at a time\n2. Verify each step before proceeding\n3. Stop at checkpoints for human review\n4. Report blockers immediately\n5. Never skip verification steps\n\n## Checkpoint Triggers:\n- Destructive operations (delete, overwrite)\n- External service interactions\n- Security-sensitive changes\n- Breaking changes to APIs\n- After completing logical groups of steps\n\n## Output Guidelines:\n- Report progress clearly\n- Include verification results\n- Ask specific questions at checkpoints\n- Provide clear options for human decisions";
+  readonly dispatchingAgents: "You are a Parallel Agent Coordinator.\nYour goal is to decompose tasks and coordinate parallel execution.\n\n## Task Decomposition:\n1. Identify independent subtasks\n2. Map dependencies between tasks\n3. Group tasks that can run in parallel\n4. Define completion conditions for each group\n\n## Coordination Strategies:\n- Fork-Join: Split work, wait for all to complete\n- Pipeline: Output of one feeds input of next\n- Scatter-Gather: Distribute work, collect results\n- Choreography: Agents coordinate directly\n\n## Output Guidelines:\n- Define clear task boundaries\n- Specify merge strategies for parallel results\n- Handle partial failures gracefully";
+  readonly subagentDrivenDev: "You are a Subagent-Driven Development Coordinator.\nYour goal is to coordinate fast iteration cycles with quality gates.\n\n## Development Cycle:\n1. Setup: Create isolated workspace\n2. Iteration: Assign tasks to specialized agents\n3. Quality Gate: Verify all quality criteria met\n4. Integration: Merge results into main codebase\n\n## Agent Roles:\n- Implementer: Writes code\n- Tester: Writes and runs tests\n- Reviewer: Reviews code quality\n- Documenter: Updates documentation\n\n## Quality Gates:\n- All tests pass\n- Code review approved\n- No security issues\n- Documentation updated\n\n## Output Guidelines:\n- Track iteration progress\n- Report quality gate status\n- Coordinate agent handoffs";
+  readonly receivingCodeReview: "You are a Code Review Response Expert.\nYour goal is to process feedback constructively and respond appropriately.\n\n## Response Process:\n1. Categorize each feedback item (bug, suggestion, nitpick)\n2. Assess severity (critical, major, minor, trivial)\n3. Decide action (accept, reject, discuss, defer)\n4. Implement accepted changes\n5. Explain rejections respectfully\n\n## Response Guidelines:\n- Thank reviewers for their time\n- Accept valid criticism gracefully\n- Explain your reasoning for rejections\n- Ask clarifying questions when needed\n- Don't argue over nitpicks\n\n## Output Guidelines:\n- Track each feedback item\n- Document your response and reasoning\n- Identify follow-up questions";
+  readonly commitAnalysis: "You are a Git Commit Message Expert following Conventional Commits specification.\n\n## Commit Types:\n- feat: New feature for the user\n- fix: Bug fix for the user\n- docs: Documentation only changes\n- style: Formatting, missing semicolons, etc.\n- refactor: Code change that neither fixes a bug nor adds a feature\n- test: Adding missing tests or correcting existing tests\n- chore: Maintenance tasks, dependency updates\n- perf: Performance improvements\n- ci: CI/CD configuration changes\n\n## Message Guidelines:\n- Subject: Imperative mood, max 50 chars, no period\n- Body: Explain WHAT and WHY, not HOW\n- Use present tense (\"add\" not \"added\")\n- Reference issues/PRs when relevant\n\n## Output Guidelines:\n- Analyze the actual changes, not just file names\n- Determine the most appropriate type\n- Identify if it's a breaking change\n- Write a clear, professional commit message";
+  readonly gitWorktree: "You are a Git Worktree Expert.\nYour goal is to manage isolated workspaces for feature development.\n\n## Worktree Setup:\n1. Select appropriate directory (.worktrees preferred)\n2. Verify .gitignore contains worktree pattern\n3. Create worktree with feature branch\n4. Auto-detect project type\n5. Install dependencies\n6. Run baseline tests\n\n## Safety Checks:\n- Never create worktrees in tracked directories\n- Always verify .gitignore before creation\n- Check for uncommitted changes\n- Validate branch names\n\n## Output Guidelines:\n- Report worktree location\n- Include test baseline status\n- Confirm feature readiness";
+  readonly finishingBranch: "You are a Branch Completion Expert.\nYour goal is to safely complete and merge development branches.\n\n## Pre-Flight Checks:\n1. All tests pass\n2. Code review approved\n3. No merge conflicts\n4. Documentation updated\n5. Changelog updated\n\n## Merge Strategies:\n- Merge: Preserves history, good for features\n- Squash: Clean history, good for small changes\n- Rebase: Linear history, good for hotfixes\n\n## Cleanup:\n1. Delete local branch\n2. Delete remote branch\n3. Remove worktree if used\n\n## Output Guidelines:\n- Report pre-flight status\n- Recommend merge strategy\n- Generate PR details if needed";
+  readonly writingSkills: "You are a Skill Definition Expert.\nYour goal is to create well-structured, reusable superpowers.\n\n## Skill Structure:\n1. Purpose: What problem does this skill solve?\n2. Core Principle: The key rule that guides this skill\n3. Phases: Sequential steps with success criteria\n4. Red Flags: Warning signs of misuse\n5. Integration Points: How it connects to other skills\n\n## Quality Criteria:\n- Clear, actionable instructions\n- Measurable success criteria\n- Appropriate scope (not too broad/narrow)\n- Well-defined output schema\n\n## Output Guidelines:\n- Provide complete skill definition\n- Include Zod schema\n- Include system prompt\n- Include usage examples";
+  readonly testingSkills: "You are a Skill Testing Expert.\nYour goal is to validate skill quality through comprehensive testing.\n\n## Test Categories:\n1. Happy Path: Does it work for normal inputs?\n2. Edge Cases: Does it handle unusual inputs?\n3. Error Cases: Does it fail gracefully?\n4. Integration: Does it work with other skills?\n\n## Quality Metrics:\n- Completeness: Are all phases covered?\n- Clarity: Are instructions unambiguous?\n- Robustness: Does it handle edge cases?\n\n## Output Guidelines:\n- Document test cases and results\n- Identify quality gaps\n- Recommend improvements";
+  readonly sharingSkills: "You are a Skill Distribution Expert.\nYour goal is to package skills for sharing across teams and platforms.\n\n## Documentation Requirements:\n- Overview: What the skill does\n- Quick Start: Minimal usage example\n- Full Documentation: Complete reference\n- Examples: Real-world usage scenarios\n\n## Compatibility:\n- Target platforms (Claude Code, Cursor, etc.)\n- Version requirements\n- Dependencies\n\n## Distribution Methods:\n- Git repository\n- NPM package\n- Manual installation\n- Marketplace";
+  readonly usingSuperpowers: "You are a Superpowers Framework Expert.\nYour goal is to introduce and guide usage of the superpowers system.\n\n## Core Principles:\n1. Think before you act - always plan first\n2. Test-driven development - tests before code\n3. Systematic over ad-hoc - follow processes\n4. Evidence over claims - verify everything\n\n## Recommended Workflow:\n1. Brainstorm: Explore requirements\n2. Plan: Create implementation plan\n3. Execute: Follow plan with checkpoints\n4. Review: Quality check all code\n5. Finish: Complete and merge\n\n## Anti-Patterns:\n- Jumping straight to code\n- Skipping tests\n- Making assumptions\n- Ignoring review feedback";
+};
+type SystemPromptKey = keyof typeof systemPrompts;
+//#endregion
+//#region src/tools/superpowers/tools/index.d.ts
+type GenerateValidatedObjectFn = <T>(prompt: string, schema: z.ZodType<T>, options?: {
+  system?: string;
+}) => Promise<T>;
+declare function initSuperpowers(deps: {
+  generateValidatedObject: GenerateValidatedObjectFn;
+}): void;
+declare const refineRequirements: ai.Tool<{
+  rawRequest: string;
+  projectContext?: string | undefined;
+  existingCode?: string | undefined;
+}, {
+  analysis: {
+    ambiguityScore: number;
+    missingContext: string[];
+    assumptions: string[];
+  };
+  clarifyingQuestions: {
+    question: string;
+    priority: "critical" | "important" | "nice-to-have";
+    context: string;
+  }[];
+  edgeCases: {
+    scenario: string;
+    risk: "low" | "medium" | "high";
+    mitigation?: string | undefined;
+  }[];
+  approaches: {
+    name: string;
+    description: string;
+    pros: string[];
+    cons: string[];
+    estimatedComplexity: "simple" | "moderate" | "complex";
+    techStackRecommendation?: string | undefined;
+  }[];
+}>;
+declare const consultArchitect: ai.Tool<{
+  featureRequest: string;
+  currentContext: string;
+  constraints?: string[] | undefined;
+  existingCode?: string | undefined;
+}, {
+  summary: string;
+  riskAnalysis: {
+    risk: string;
+    severity: "critical" | "low" | "medium" | "high";
+    mitigation: string;
+  }[];
+  dependencies: {
+    name: string;
+    type: "file" | "package" | "service" | "api" | "database";
+    status: "exists" | "needs-creation" | "needs-modification";
+  }[];
+  steps: {
+    order: number;
+    title: string;
+    filePaths: string[];
+    actionType: "create" | "modify" | "delete" | "refactor" | "test" | "configure";
+    description: string;
+    verificationCmd: string;
+    blockedBy?: number[] | undefined;
+  }[];
+  rollbackPlan?: string | undefined;
+}>;
+declare const reviewDesign: ai.Tool<{
+  proposedChanges: string;
+  conventions: string;
+  existingArchitecture?: string | undefined;
+  affectedAreas?: string[] | undefined;
+}, {
+  adheresToConventions: boolean;
+  conventionViolations: {
+    convention: string;
+    violation: string;
+    severity: "moderate" | "minor" | "severe";
+    suggestion: string;
+  }[];
+  architecturalConcerns: {
+    concern: string;
+    impact: "low" | "medium" | "high";
+    recommendation: string;
+  }[];
+  compatibility: {
+    backwardsCompatible: boolean;
+    breakingChanges: string[];
+    migrationRequired: boolean;
+    migrationSteps?: string[] | undefined;
+  };
+  recommendations: string[];
+  approval: "approved" | "approved-with-changes" | "rejected";
+}>;
+declare const runTDDCycle: ai.Tool<{
+  feature: string;
+  testFramework: "vitest" | "jest" | "mocha" | "playwright";
+  targetPath: string;
+  iteration: number;
+  existingTests?: string | undefined;
+  previousResult?: string | undefined;
+}, {
+  phase: "refactor" | "write-test" | "run-test" | "implement" | "complete";
+  iteration: number;
+  nextAction: string;
+  confidence: number;
+  testFile?: {
+    path: string;
+    content: string;
+    description: string;
+  } | undefined;
+  implementation?: {
+    path: string;
+    content: string;
+    description: string;
+  } | undefined;
+  testResult?: {
+    passed: boolean;
+    output: string;
+    failureReason?: string | undefined;
+  } | undefined;
+}>;
+declare const reviewCode: ai.Tool<{
+  code: string;
+  language: "other" | "python" | "rust" | "go" | "java" | "typescript" | "javascript";
+  context?: string | undefined;
+  projectConventions?: string | undefined;
+  focusAreas?: ("security" | "performance" | "maintainability" | "testing")[] | undefined;
+}, {
+  summary: {
+    overallScore: number;
+    recommendation: "approve" | "request-changes" | "needs-discussion";
+    reviewerConfidence: number;
+  };
+  categories: {
+    security: {
+      score: number;
+      issues: {
+        severity: "error" | "warning" | "info" | "critical";
+        message: string;
+        line?: number | undefined;
+        suggestion?: string | undefined;
+      }[];
+    };
+    performance: {
+      score: number;
+      issues: {
+        severity: "error" | "warning" | "info";
+        message: string;
+        line?: number | undefined;
+        suggestion?: string | undefined;
+      }[];
+    };
+    maintainability: {
+      score: number;
+      issues: {
+        severity: "error" | "warning" | "info";
+        message: string;
+        line?: number | undefined;
+        suggestion?: string | undefined;
+      }[];
+    };
+    testCoverage: {
+      score: number;
+      missingTests: string[];
+    };
+  };
+  antiPatterns: {
+    name: string;
+    location: string;
+    description: string;
+    suggestedFix: string;
+  }[];
+  positives: string[];
+}>;
+declare const detectAntiPatterns: ai.Tool<{
+  code: string;
+  filePath: string;
+  language: "other" | "python" | "rust" | "go" | "java" | "typescript" | "javascript";
+  strictMode: boolean;
+}, {
+  detected: boolean;
+  patterns: {
+    name: string;
+    severity: "moderate" | "minor" | "severe";
+    location: {
+      file: string;
+      line?: number | undefined;
+      snippet?: string | undefined;
+    };
+    description: string;
+    why: string;
+    fix: string;
+    category: "security" | "hardcoding" | "error-swallowing" | "magic-numbers" | "god-object" | "over-engineering" | "premature-optimization" | "copy-paste" | "other";
+  }[];
+  score: number;
+}>;
+declare const systematicDebug: ai.Tool<{
+  symptom: string;
+  context: string;
+  recentChanges?: string[] | undefined;
+  failingCode?: string | undefined;
+}, {
+  phase: "implementation" | "investigation" | "pattern-analysis" | "hypothesis-testing";
+  investigation: {
+    errorMessages: string[];
+    reproductionSteps: string[];
+    recentChanges: string[];
+    dataFlowTrace: string;
+    failurePoint: string;
+    rootCauseHypothesis: string;
+  };
+  confidence: number;
+  redFlags: string[];
+  patternAnalysis?: {
+    workingCodeExamples: string[];
+    differences: string[];
+    missingDependencies: string[];
+  } | undefined;
+  hypothesis?: {
+    statement: string;
+    testPlan: string;
+    iterations: number;
+    result?: "rejected" | "confirmed" | "inconclusive" | undefined;
+  } | undefined;
+  fix?: {
+    testCase: string;
+    implementation: string;
+    verification: string;
+  } | undefined;
+}>;
+declare const traceRootCause: ai.Tool<{
+  symptom: string;
+  systemLayers: string[];
+  codeContext?: string | undefined;
+}, {
+  symptom: string;
+  traceSteps: {
+    layer: string;
+    component: string;
+    finding: string;
+    isRootCause: boolean;
+  }[];
+  rootCause: {
+    location: string;
+    description: string;
+    category: "other" | "logic-error" | "data-corruption" | "race-condition" | "missing-validation" | "configuration" | "dependency" | "resource-exhaustion";
+  };
+  contributingFactors: string[];
+  preventionRecommendations: string[];
+}>;
+declare const analyzeDefenseInDepth: ai.Tool<{
+  component: string;
+  code: string;
+  threatModel?: string | undefined;
+}, {
+  layers: {
+    name: string;
+    type: "input-validation" | "authentication" | "authorization" | "encryption" | "logging" | "rate-limiting" | "error-handling" | "backup";
+    status: "present" | "missing" | "partial";
+    strength: "strong" | "adequate" | "weak";
+    recommendations: string[];
+  }[];
+  overallScore: number;
+  criticalGaps: string[];
+  redundancyAnalysis: {
+    hasRedundancy: boolean;
+    singlePointsOfFailure: string[];
+  };
+  gaps: {
+    name: string;
+    severity: "critical" | "low" | "medium" | "high";
+    recommendation: string;
+  }[];
+  recommendations: string[];
+}>;
+declare const analyzeAsyncPatterns: ai.Tool<{
+  code: string;
+  framework: "other" | "vitest" | "jest" | "playwright" | "cypress";
+}, {
+  asyncOperations: {
+    description: string;
+    type: "network" | "timer" | "animation" | "state-change" | "dom-update" | "file-io";
+    waitStrategy: "promise" | "polling" | "event-listener" | "callback" | "observable";
+    condition: string;
+    timeout: number;
+    fallback: string;
+  }[];
+  raceConditions: {
+    description: string;
+    location: string;
+    fix: string;
+  }[];
+  antiPatterns: {
+    pattern: string;
+    location: string;
+    betterApproach: string;
+  }[];
+  recommendations: string[];
+}>;
+declare const executePlan: ai.Tool<{
+  plan: string;
+  currentStep: number;
+  previousResults?: string | undefined;
+}, {
+  planId: string;
+  currentStep: number;
+  totalSteps: number;
+  status: "completed" | "failed" | "in-progress" | "checkpoint" | "blocked";
+  executedSteps: {
+    stepNumber: number;
+    title: string;
+    status: "completed" | "failed" | "skipped";
+    output?: string | undefined;
+    verificationResult?: string | undefined;
+    duration?: number | undefined;
+  }[];
+  nextAction: string;
+  checkpoint?: {
+    reason: string;
+    question: string;
+    options: string[];
+  } | undefined;
+  blockers?: string[] | undefined;
+}>;
+declare const dispatchAgents: ai.Tool<{
+  task: string;
+  availableAgents: string[];
+  constraints?: string | undefined;
+}, {
+  taskDecomposition: {
+    taskId: string;
+    description: string;
+    dependencies: string[];
+    estimatedDuration: string;
+    agentType: "test" | "implement" | "brainstorm" | "plan" | "review" | "document";
+  }[];
+  parallelGroups: {
+    groupId: string;
+    tasks: string[];
+    completionCondition: "any" | "all" | "majority";
+  }[];
+  executionOrder: string[];
+  coordinationStrategy: "fork-join" | "pipeline" | "scatter-gather" | "choreography";
+  mergeStrategy: string;
+}>;
+declare const runSubagentDev: ai.Tool<{
+  objective: string;
+  qualityGates: string[];
+  iteration: number;
+}, {
+  phase: "complete" | "iteration" | "setup" | "quality-gate" | "integration";
+  status: "success" | "running" | "failed" | "pending";
+  iteration: {
+    number: number;
+    objective: string;
+    agentAssignments: {
+      agentId: string;
+      role: string;
+      task: string;
+      status: "running" | "completed" | "failed" | "pending";
+    }[];
+  };
+  qualityGates: {
+    name: string;
+    criteria: string;
+    passed?: boolean | undefined;
+    blockers?: string[] | undefined;
+  }[];
+  artifacts: {
+    type: "code" | "test" | "documentation" | "config";
+    path: string;
+    status: "created" | "modified" | "verified";
+  }[];
+  nextIteration?: string | undefined;
+}>;
+declare const processCodeReview: ai.Tool<{
+  feedback: string;
+  originalCode: string;
+  reviewerId?: string | undefined;
+}, {
+  reviewId: string;
+  allAddressed: boolean;
+  feedbackItems: {
+    id: string;
+    type: "question" | "suggestion" | "bug" | "nitpick" | "praise";
+    severity: "critical" | "minor" | "major" | "trivial";
+    comment: string;
+    file?: string | undefined;
+    line?: number | undefined;
+    response?: {
+      action: "rejected" | "accepted" | "discussed" | "deferred";
+      explanation: string;
+      implementation?: string | undefined;
+    } | undefined;
+  }[];
+  summary: {
+    totalItems: number;
+    addressed: number;
+    deferred: number;
+    rejected: number;
+  };
+  followUpQuestions: string[];
+  updatedCode?: string | undefined;
+}>;
+declare const analyzeCommit: ai.Tool<{
+  diff: string;
+  changedFiles: string[];
+  context?: string | undefined;
+  relatedIssue?: string | undefined;
+}, {
+  type: "refactor" | "test" | "fix" | "feat" | "docs" | "style" | "chore" | "perf" | "ci";
+  subject: string;
+  fullMessage: string;
+  confidence: number;
+  scope?: string | undefined;
+  body?: string | undefined;
+  breakingChange?: {
+    isBreaking: boolean;
+    description?: string | undefined;
+  } | undefined;
+  relatedIssues?: string[] | undefined;
+}>;
+declare const manageWorktree: ai.Tool<{
+  action: "create" | "list" | "remove" | "switch";
+  branchName?: string | undefined;
+  baseBranch?: string | undefined;
+  path?: string | undefined;
+}, {
+  action: "create" | "list" | "remove" | "switch";
+  safetyChecks: {
+    gitignoreVerified: boolean;
+    noUncommittedChanges: boolean;
+    branchNameValid: boolean;
+  };
+  worktree?: {
+    path: string;
+    branch: string;
+    isClean: boolean;
+    baseBranch?: string | undefined;
+  } | undefined;
+  setup?: {
+    projectType: "other" | "nodejs" | "python" | "rust" | "go" | "java";
+    dependenciesInstalled: boolean;
+    testsRun: boolean;
+    baselineEstablished: boolean;
+    testsPassed?: boolean | undefined;
+  } | undefined;
+  existingWorktrees?: {
+    path: string;
+    branch: string;
+    isLocked: boolean;
+  }[] | undefined;
+}>;
+declare const finishBranch: ai.Tool<{
+  branchName: string;
+  targetBranch: string;
+  createPR: boolean;
+}, {
+  branch: string;
+  status: "ready" | "ready-to-merge" | "ready-for-pr" | "needs-work" | "merged" | "abandoned";
+  preFlightChecks: {
+    check: string;
+    passed: boolean;
+    details?: string | undefined;
+  }[];
+  cleanup: {
+    localBranchDeleted: boolean;
+    remoteBranchDeleted: boolean;
+    worktreeRemoved?: boolean | undefined;
+  };
+  mergeStrategy?: {
+    recommendation: "merge" | "squash" | "rebase";
+    reason: string;
+    targetBranch: string;
+  } | undefined;
+  prDetails?: {
+    title: string;
+    body: string;
+    labels: string[];
+    reviewers?: string[] | undefined;
+  } | undefined;
+}>;
+declare const writeSkill: ai.Tool<{
+  skillName: string;
+  purpose: string;
+  examples: string[];
+}, {
+  skillName: string;
+  skillDefinition: {
+    purpose: string;
+    corePrinciple: string;
+    phases: {
+      name: string;
+      activities: string[];
+      successCriterion: string;
+    }[];
+    redFlags: string[];
+    integrationPoints: {
+      calledBy: string[];
+      pairsWith: string[];
+    };
+  };
+  outputSchema: string;
+  systemPrompt: string;
+  exampleUsage: string;
+  implementation?: string | undefined;
+}>;
+declare const testSkill: ai.Tool<{
+  skillDefinition: string;
+  testCases: string[];
+}, {
+  skillName: string;
+  passRate: number;
+  testCases: {
+    name: string;
+    input: string;
+    expectedBehavior: string;
+    actualResult?: string | undefined;
+    passed?: boolean | undefined;
+  }[];
+  edgeCases: {
+    scenario: string;
+    handled: boolean;
+    notes?: string | undefined;
+  }[];
+  qualityMetrics: {
+    completeness: number;
+    clarity: number;
+    robustness: number;
+  };
+  recommendations: string[];
+}>;
+declare const shareSkill: ai.Tool<{
+  skillDefinition: string;
+  targetPlatforms: string[];
+  version: string;
+}, {
+  skillName: string;
+  exportFormat: "markdown" | "json" | "yaml";
+  documentation: {
+    overview: string;
+    quickStart: string;
+    fullDocumentation: string;
+    examples: string[];
+  };
+  compatibility: {
+    platforms: ("other" | "claude-code" | "cursor" | "windsurf")[];
+    version: string;
+    dependencies: string[];
+  };
+  distribution: {
+    method: "git" | "npm" | "manual" | "marketplace";
+    location: string;
+    installInstructions: string;
+  };
+}>;
+declare const introduceSuperpowers: ai.Tool<{
+  projectContext: string;
+  userExperience: "beginner" | "intermediate" | "expert";
+}, {
+  availableSuperpowers: {
+    name: string;
+    category: "git" | "planning" | "debugging" | "quality" | "workflow" | "meta";
+    description: string;
+    whenToUse: string;
+  }[];
+  recommendedWorkflow: {
+    step: number;
+    superpower: string;
+    purpose: string;
+  }[];
+  corePrinciples: string[];
+  antiPatterns: {
+    pattern: string;
+    why: string;
+    instead: string;
+  }[];
+}>;
+declare const planningTools: {
+  readonly refineRequirements: ai.Tool<{
+    rawRequest: string;
+    projectContext?: string | undefined;
+    existingCode?: string | undefined;
+  }, {
+    analysis: {
+      ambiguityScore: number;
+      missingContext: string[];
+      assumptions: string[];
+    };
+    clarifyingQuestions: {
+      question: string;
+      priority: "critical" | "important" | "nice-to-have";
+      context: string;
+    }[];
+    edgeCases: {
+      scenario: string;
+      risk: "low" | "medium" | "high";
+      mitigation?: string | undefined;
+    }[];
+    approaches: {
+      name: string;
+      description: string;
+      pros: string[];
+      cons: string[];
+      estimatedComplexity: "simple" | "moderate" | "complex";
+      techStackRecommendation?: string | undefined;
+    }[];
+  }>;
+  readonly consultArchitect: ai.Tool<{
+    featureRequest: string;
+    currentContext: string;
+    constraints?: string[] | undefined;
+    existingCode?: string | undefined;
+  }, {
+    summary: string;
+    riskAnalysis: {
+      risk: string;
+      severity: "critical" | "low" | "medium" | "high";
+      mitigation: string;
+    }[];
+    dependencies: {
+      name: string;
+      type: "file" | "package" | "service" | "api" | "database";
+      status: "exists" | "needs-creation" | "needs-modification";
+    }[];
+    steps: {
+      order: number;
+      title: string;
+      filePaths: string[];
+      actionType: "create" | "modify" | "delete" | "refactor" | "test" | "configure";
+      description: string;
+      verificationCmd: string;
+      blockedBy?: number[] | undefined;
+    }[];
+    rollbackPlan?: string | undefined;
+  }>;
+  readonly reviewDesign: ai.Tool<{
+    proposedChanges: string;
+    conventions: string;
+    existingArchitecture?: string | undefined;
+    affectedAreas?: string[] | undefined;
+  }, {
+    adheresToConventions: boolean;
+    conventionViolations: {
+      convention: string;
+      violation: string;
+      severity: "moderate" | "minor" | "severe";
+      suggestion: string;
+    }[];
+    architecturalConcerns: {
+      concern: string;
+      impact: "low" | "medium" | "high";
+      recommendation: string;
+    }[];
+    compatibility: {
+      backwardsCompatible: boolean;
+      breakingChanges: string[];
+      migrationRequired: boolean;
+      migrationSteps?: string[] | undefined;
+    };
+    recommendations: string[];
+    approval: "approved" | "approved-with-changes" | "rejected";
+  }>;
+};
+declare const qualityTools: {
+  readonly runTDDCycle: ai.Tool<{
+    feature: string;
+    testFramework: "vitest" | "jest" | "mocha" | "playwright";
+    targetPath: string;
+    iteration: number;
+    existingTests?: string | undefined;
+    previousResult?: string | undefined;
+  }, {
+    phase: "refactor" | "write-test" | "run-test" | "implement" | "complete";
+    iteration: number;
+    nextAction: string;
+    confidence: number;
+    testFile?: {
+      path: string;
+      content: string;
+      description: string;
+    } | undefined;
+    implementation?: {
+      path: string;
+      content: string;
+      description: string;
+    } | undefined;
+    testResult?: {
+      passed: boolean;
+      output: string;
+      failureReason?: string | undefined;
+    } | undefined;
+  }>;
+  readonly reviewCode: ai.Tool<{
+    code: string;
+    language: "other" | "python" | "rust" | "go" | "java" | "typescript" | "javascript";
+    context?: string | undefined;
+    projectConventions?: string | undefined;
+    focusAreas?: ("security" | "performance" | "maintainability" | "testing")[] | undefined;
+  }, {
+    summary: {
+      overallScore: number;
+      recommendation: "approve" | "request-changes" | "needs-discussion";
+      reviewerConfidence: number;
+    };
+    categories: {
+      security: {
+        score: number;
+        issues: {
+          severity: "error" | "warning" | "info" | "critical";
+          message: string;
+          line?: number | undefined;
+          suggestion?: string | undefined;
+        }[];
+      };
+      performance: {
+        score: number;
+        issues: {
+          severity: "error" | "warning" | "info";
+          message: string;
+          line?: number | undefined;
+          suggestion?: string | undefined;
+        }[];
+      };
+      maintainability: {
+        score: number;
+        issues: {
+          severity: "error" | "warning" | "info";
+          message: string;
+          line?: number | undefined;
+          suggestion?: string | undefined;
+        }[];
+      };
+      testCoverage: {
+        score: number;
+        missingTests: string[];
+      };
+    };
+    antiPatterns: {
+      name: string;
+      location: string;
+      description: string;
+      suggestedFix: string;
+    }[];
+    positives: string[];
+  }>;
+  readonly detectAntiPatterns: ai.Tool<{
+    code: string;
+    filePath: string;
+    language: "other" | "python" | "rust" | "go" | "java" | "typescript" | "javascript";
+    strictMode: boolean;
+  }, {
+    detected: boolean;
+    patterns: {
+      name: string;
+      severity: "moderate" | "minor" | "severe";
+      location: {
+        file: string;
+        line?: number | undefined;
+        snippet?: string | undefined;
+      };
+      description: string;
+      why: string;
+      fix: string;
+      category: "security" | "hardcoding" | "error-swallowing" | "magic-numbers" | "god-object" | "over-engineering" | "premature-optimization" | "copy-paste" | "other";
+    }[];
+    score: number;
+  }>;
+};
+declare const debuggingTools: {
+  readonly systematicDebug: ai.Tool<{
+    symptom: string;
+    context: string;
+    recentChanges?: string[] | undefined;
+    failingCode?: string | undefined;
+  }, {
+    phase: "implementation" | "investigation" | "pattern-analysis" | "hypothesis-testing";
+    investigation: {
+      errorMessages: string[];
+      reproductionSteps: string[];
+      recentChanges: string[];
+      dataFlowTrace: string;
+      failurePoint: string;
+      rootCauseHypothesis: string;
+    };
+    confidence: number;
+    redFlags: string[];
+    patternAnalysis?: {
+      workingCodeExamples: string[];
+      differences: string[];
+      missingDependencies: string[];
+    } | undefined;
+    hypothesis?: {
+      statement: string;
+      testPlan: string;
+      iterations: number;
+      result?: "rejected" | "confirmed" | "inconclusive" | undefined;
+    } | undefined;
+    fix?: {
+      testCase: string;
+      implementation: string;
+      verification: string;
+    } | undefined;
+  }>;
+  readonly traceRootCause: ai.Tool<{
+    symptom: string;
+    systemLayers: string[];
+    codeContext?: string | undefined;
+  }, {
+    symptom: string;
+    traceSteps: {
+      layer: string;
+      component: string;
+      finding: string;
+      isRootCause: boolean;
+    }[];
+    rootCause: {
+      location: string;
+      description: string;
+      category: "other" | "logic-error" | "data-corruption" | "race-condition" | "missing-validation" | "configuration" | "dependency" | "resource-exhaustion";
+    };
+    contributingFactors: string[];
+    preventionRecommendations: string[];
+  }>;
+  readonly analyzeDefenseInDepth: ai.Tool<{
+    component: string;
+    code: string;
+    threatModel?: string | undefined;
+  }, {
+    layers: {
+      name: string;
+      type: "input-validation" | "authentication" | "authorization" | "encryption" | "logging" | "rate-limiting" | "error-handling" | "backup";
+      status: "present" | "missing" | "partial";
+      strength: "strong" | "adequate" | "weak";
+      recommendations: string[];
+    }[];
+    overallScore: number;
+    criticalGaps: string[];
+    redundancyAnalysis: {
+      hasRedundancy: boolean;
+      singlePointsOfFailure: string[];
+    };
+    gaps: {
+      name: string;
+      severity: "critical" | "low" | "medium" | "high";
+      recommendation: string;
+    }[];
+    recommendations: string[];
+  }>;
+  readonly analyzeAsyncPatterns: ai.Tool<{
+    code: string;
+    framework: "other" | "vitest" | "jest" | "playwright" | "cypress";
+  }, {
+    asyncOperations: {
+      description: string;
+      type: "network" | "timer" | "animation" | "state-change" | "dom-update" | "file-io";
+      waitStrategy: "promise" | "polling" | "event-listener" | "callback" | "observable";
+      condition: string;
+      timeout: number;
+      fallback: string;
+    }[];
+    raceConditions: {
+      description: string;
+      location: string;
+      fix: string;
+    }[];
+    antiPatterns: {
+      pattern: string;
+      location: string;
+      betterApproach: string;
+    }[];
+    recommendations: string[];
+  }>;
+};
+declare const workflowTools: {
+  readonly executePlan: ai.Tool<{
+    plan: string;
+    currentStep: number;
+    previousResults?: string | undefined;
+  }, {
+    planId: string;
+    currentStep: number;
+    totalSteps: number;
+    status: "completed" | "failed" | "in-progress" | "checkpoint" | "blocked";
+    executedSteps: {
+      stepNumber: number;
+      title: string;
+      status: "completed" | "failed" | "skipped";
+      output?: string | undefined;
+      verificationResult?: string | undefined;
+      duration?: number | undefined;
+    }[];
+    nextAction: string;
+    checkpoint?: {
+      reason: string;
+      question: string;
+      options: string[];
+    } | undefined;
+    blockers?: string[] | undefined;
+  }>;
+  readonly dispatchAgents: ai.Tool<{
+    task: string;
+    availableAgents: string[];
+    constraints?: string | undefined;
+  }, {
+    taskDecomposition: {
+      taskId: string;
+      description: string;
+      dependencies: string[];
+      estimatedDuration: string;
+      agentType: "test" | "implement" | "brainstorm" | "plan" | "review" | "document";
+    }[];
+    parallelGroups: {
+      groupId: string;
+      tasks: string[];
+      completionCondition: "any" | "all" | "majority";
+    }[];
+    executionOrder: string[];
+    coordinationStrategy: "fork-join" | "pipeline" | "scatter-gather" | "choreography";
+    mergeStrategy: string;
+  }>;
+  readonly runSubagentDev: ai.Tool<{
+    objective: string;
+    qualityGates: string[];
+    iteration: number;
+  }, {
+    phase: "complete" | "iteration" | "setup" | "quality-gate" | "integration";
+    status: "success" | "running" | "failed" | "pending";
+    iteration: {
+      number: number;
+      objective: string;
+      agentAssignments: {
+        agentId: string;
+        role: string;
+        task: string;
+        status: "running" | "completed" | "failed" | "pending";
+      }[];
+    };
+    qualityGates: {
+      name: string;
+      criteria: string;
+      passed?: boolean | undefined;
+      blockers?: string[] | undefined;
+    }[];
+    artifacts: {
+      type: "code" | "test" | "documentation" | "config";
+      path: string;
+      status: "created" | "modified" | "verified";
+    }[];
+    nextIteration?: string | undefined;
+  }>;
+};
+declare const codeReviewTools: {
+  readonly reviewCode: ai.Tool<{
+    code: string;
+    language: "other" | "python" | "rust" | "go" | "java" | "typescript" | "javascript";
+    context?: string | undefined;
+    projectConventions?: string | undefined;
+    focusAreas?: ("security" | "performance" | "maintainability" | "testing")[] | undefined;
+  }, {
+    summary: {
+      overallScore: number;
+      recommendation: "approve" | "request-changes" | "needs-discussion";
+      reviewerConfidence: number;
+    };
+    categories: {
+      security: {
+        score: number;
+        issues: {
+          severity: "error" | "warning" | "info" | "critical";
+          message: string;
+          line?: number | undefined;
+          suggestion?: string | undefined;
+        }[];
+      };
+      performance: {
+        score: number;
+        issues: {
+          severity: "error" | "warning" | "info";
+          message: string;
+          line?: number | undefined;
+          suggestion?: string | undefined;
+        }[];
+      };
+      maintainability: {
+        score: number;
+        issues: {
+          severity: "error" | "warning" | "info";
+          message: string;
+          line?: number | undefined;
+          suggestion?: string | undefined;
+        }[];
+      };
+      testCoverage: {
+        score: number;
+        missingTests: string[];
+      };
+    };
+    antiPatterns: {
+      name: string;
+      location: string;
+      description: string;
+      suggestedFix: string;
+    }[];
+    positives: string[];
+  }>;
+  readonly processCodeReview: ai.Tool<{
+    feedback: string;
+    originalCode: string;
+    reviewerId?: string | undefined;
+  }, {
+    reviewId: string;
+    allAddressed: boolean;
+    feedbackItems: {
+      id: string;
+      type: "question" | "suggestion" | "bug" | "nitpick" | "praise";
+      severity: "critical" | "minor" | "major" | "trivial";
+      comment: string;
+      file?: string | undefined;
+      line?: number | undefined;
+      response?: {
+        action: "rejected" | "accepted" | "discussed" | "deferred";
+        explanation: string;
+        implementation?: string | undefined;
+      } | undefined;
+    }[];
+    summary: {
+      totalItems: number;
+      addressed: number;
+      deferred: number;
+      rejected: number;
+    };
+    followUpQuestions: string[];
+    updatedCode?: string | undefined;
+  }>;
+  readonly detectAntiPatterns: ai.Tool<{
+    code: string;
+    filePath: string;
+    language: "other" | "python" | "rust" | "go" | "java" | "typescript" | "javascript";
+    strictMode: boolean;
+  }, {
+    detected: boolean;
+    patterns: {
+      name: string;
+      severity: "moderate" | "minor" | "severe";
+      location: {
+        file: string;
+        line?: number | undefined;
+        snippet?: string | undefined;
+      };
+      description: string;
+      why: string;
+      fix: string;
+      category: "security" | "hardcoding" | "error-swallowing" | "magic-numbers" | "god-object" | "over-engineering" | "premature-optimization" | "copy-paste" | "other";
+    }[];
+    score: number;
+  }>;
+};
+declare const gitTools: {
+  readonly analyzeCommit: ai.Tool<{
+    diff: string;
+    changedFiles: string[];
+    context?: string | undefined;
+    relatedIssue?: string | undefined;
+  }, {
+    type: "refactor" | "test" | "fix" | "feat" | "docs" | "style" | "chore" | "perf" | "ci";
+    subject: string;
+    fullMessage: string;
+    confidence: number;
+    scope?: string | undefined;
+    body?: string | undefined;
+    breakingChange?: {
+      isBreaking: boolean;
+      description?: string | undefined;
+    } | undefined;
+    relatedIssues?: string[] | undefined;
+  }>;
+  readonly manageWorktree: ai.Tool<{
+    action: "create" | "list" | "remove" | "switch";
+    branchName?: string | undefined;
+    baseBranch?: string | undefined;
+    path?: string | undefined;
+  }, {
+    action: "create" | "list" | "remove" | "switch";
+    safetyChecks: {
+      gitignoreVerified: boolean;
+      noUncommittedChanges: boolean;
+      branchNameValid: boolean;
+    };
+    worktree?: {
+      path: string;
+      branch: string;
+      isClean: boolean;
+      baseBranch?: string | undefined;
+    } | undefined;
+    setup?: {
+      projectType: "other" | "nodejs" | "python" | "rust" | "go" | "java";
+      dependenciesInstalled: boolean;
+      testsRun: boolean;
+      baselineEstablished: boolean;
+      testsPassed?: boolean | undefined;
+    } | undefined;
+    existingWorktrees?: {
+      path: string;
+      branch: string;
+      isLocked: boolean;
+    }[] | undefined;
+  }>;
+  readonly finishBranch: ai.Tool<{
+    branchName: string;
+    targetBranch: string;
+    createPR: boolean;
+  }, {
+    branch: string;
+    status: "ready" | "ready-to-merge" | "ready-for-pr" | "needs-work" | "merged" | "abandoned";
+    preFlightChecks: {
+      check: string;
+      passed: boolean;
+      details?: string | undefined;
+    }[];
+    cleanup: {
+      localBranchDeleted: boolean;
+      remoteBranchDeleted: boolean;
+      worktreeRemoved?: boolean | undefined;
+    };
+    mergeStrategy?: {
+      recommendation: "merge" | "squash" | "rebase";
+      reason: string;
+      targetBranch: string;
+    } | undefined;
+    prDetails?: {
+      title: string;
+      body: string;
+      labels: string[];
+      reviewers?: string[] | undefined;
+    } | undefined;
+  }>;
+};
+declare const metaTools: {
+  readonly writeSkill: ai.Tool<{
+    skillName: string;
+    purpose: string;
+    examples: string[];
+  }, {
+    skillName: string;
+    skillDefinition: {
+      purpose: string;
+      corePrinciple: string;
+      phases: {
+        name: string;
+        activities: string[];
+        successCriterion: string;
+      }[];
+      redFlags: string[];
+      integrationPoints: {
+        calledBy: string[];
+        pairsWith: string[];
+      };
+    };
+    outputSchema: string;
+    systemPrompt: string;
+    exampleUsage: string;
+    implementation?: string | undefined;
+  }>;
+  readonly testSkill: ai.Tool<{
+    skillDefinition: string;
+    testCases: string[];
+  }, {
+    skillName: string;
+    passRate: number;
+    testCases: {
+      name: string;
+      input: string;
+      expectedBehavior: string;
+      actualResult?: string | undefined;
+      passed?: boolean | undefined;
+    }[];
+    edgeCases: {
+      scenario: string;
+      handled: boolean;
+      notes?: string | undefined;
+    }[];
+    qualityMetrics: {
+      completeness: number;
+      clarity: number;
+      robustness: number;
+    };
+    recommendations: string[];
+  }>;
+  readonly shareSkill: ai.Tool<{
+    skillDefinition: string;
+    targetPlatforms: string[];
+    version: string;
+  }, {
+    skillName: string;
+    exportFormat: "markdown" | "json" | "yaml";
+    documentation: {
+      overview: string;
+      quickStart: string;
+      fullDocumentation: string;
+      examples: string[];
+    };
+    compatibility: {
+      platforms: ("other" | "claude-code" | "cursor" | "windsurf")[];
+      version: string;
+      dependencies: string[];
+    };
+    distribution: {
+      method: "git" | "npm" | "manual" | "marketplace";
+      location: string;
+      installInstructions: string;
+    };
+  }>;
+  readonly introduceSuperpowers: ai.Tool<{
+    projectContext: string;
+    userExperience: "beginner" | "intermediate" | "expert";
+  }, {
+    availableSuperpowers: {
+      name: string;
+      category: "git" | "planning" | "debugging" | "quality" | "workflow" | "meta";
+      description: string;
+      whenToUse: string;
+    }[];
+    recommendedWorkflow: {
+      step: number;
+      superpower: string;
+      purpose: string;
+    }[];
+    corePrinciples: string[];
+    antiPatterns: {
+      pattern: string;
+      why: string;
+      instead: string;
+    }[];
+  }>;
+};
+declare const allSuperpowerTools: {
+  readonly writeSkill: ai.Tool<{
+    skillName: string;
+    purpose: string;
+    examples: string[];
+  }, {
+    skillName: string;
+    skillDefinition: {
+      purpose: string;
+      corePrinciple: string;
+      phases: {
+        name: string;
+        activities: string[];
+        successCriterion: string;
+      }[];
+      redFlags: string[];
+      integrationPoints: {
+        calledBy: string[];
+        pairsWith: string[];
+      };
+    };
+    outputSchema: string;
+    systemPrompt: string;
+    exampleUsage: string;
+    implementation?: string | undefined;
+  }>;
+  readonly testSkill: ai.Tool<{
+    skillDefinition: string;
+    testCases: string[];
+  }, {
+    skillName: string;
+    passRate: number;
+    testCases: {
+      name: string;
+      input: string;
+      expectedBehavior: string;
+      actualResult?: string | undefined;
+      passed?: boolean | undefined;
+    }[];
+    edgeCases: {
+      scenario: string;
+      handled: boolean;
+      notes?: string | undefined;
+    }[];
+    qualityMetrics: {
+      completeness: number;
+      clarity: number;
+      robustness: number;
+    };
+    recommendations: string[];
+  }>;
+  readonly shareSkill: ai.Tool<{
+    skillDefinition: string;
+    targetPlatforms: string[];
+    version: string;
+  }, {
+    skillName: string;
+    exportFormat: "markdown" | "json" | "yaml";
+    documentation: {
+      overview: string;
+      quickStart: string;
+      fullDocumentation: string;
+      examples: string[];
+    };
+    compatibility: {
+      platforms: ("other" | "claude-code" | "cursor" | "windsurf")[];
+      version: string;
+      dependencies: string[];
+    };
+    distribution: {
+      method: "git" | "npm" | "manual" | "marketplace";
+      location: string;
+      installInstructions: string;
+    };
+  }>;
+  readonly introduceSuperpowers: ai.Tool<{
+    projectContext: string;
+    userExperience: "beginner" | "intermediate" | "expert";
+  }, {
+    availableSuperpowers: {
+      name: string;
+      category: "git" | "planning" | "debugging" | "quality" | "workflow" | "meta";
+      description: string;
+      whenToUse: string;
+    }[];
+    recommendedWorkflow: {
+      step: number;
+      superpower: string;
+      purpose: string;
+    }[];
+    corePrinciples: string[];
+    antiPatterns: {
+      pattern: string;
+      why: string;
+      instead: string;
+    }[];
+  }>;
+  readonly analyzeCommit: ai.Tool<{
+    diff: string;
+    changedFiles: string[];
+    context?: string | undefined;
+    relatedIssue?: string | undefined;
+  }, {
+    type: "refactor" | "test" | "fix" | "feat" | "docs" | "style" | "chore" | "perf" | "ci";
+    subject: string;
+    fullMessage: string;
+    confidence: number;
+    scope?: string | undefined;
+    body?: string | undefined;
+    breakingChange?: {
+      isBreaking: boolean;
+      description?: string | undefined;
+    } | undefined;
+    relatedIssues?: string[] | undefined;
+  }>;
+  readonly manageWorktree: ai.Tool<{
+    action: "create" | "list" | "remove" | "switch";
+    branchName?: string | undefined;
+    baseBranch?: string | undefined;
+    path?: string | undefined;
+  }, {
+    action: "create" | "list" | "remove" | "switch";
+    safetyChecks: {
+      gitignoreVerified: boolean;
+      noUncommittedChanges: boolean;
+      branchNameValid: boolean;
+    };
+    worktree?: {
+      path: string;
+      branch: string;
+      isClean: boolean;
+      baseBranch?: string | undefined;
+    } | undefined;
+    setup?: {
+      projectType: "other" | "nodejs" | "python" | "rust" | "go" | "java";
+      dependenciesInstalled: boolean;
+      testsRun: boolean;
+      baselineEstablished: boolean;
+      testsPassed?: boolean | undefined;
+    } | undefined;
+    existingWorktrees?: {
+      path: string;
+      branch: string;
+      isLocked: boolean;
+    }[] | undefined;
+  }>;
+  readonly finishBranch: ai.Tool<{
+    branchName: string;
+    targetBranch: string;
+    createPR: boolean;
+  }, {
+    branch: string;
+    status: "ready" | "ready-to-merge" | "ready-for-pr" | "needs-work" | "merged" | "abandoned";
+    preFlightChecks: {
+      check: string;
+      passed: boolean;
+      details?: string | undefined;
+    }[];
+    cleanup: {
+      localBranchDeleted: boolean;
+      remoteBranchDeleted: boolean;
+      worktreeRemoved?: boolean | undefined;
+    };
+    mergeStrategy?: {
+      recommendation: "merge" | "squash" | "rebase";
+      reason: string;
+      targetBranch: string;
+    } | undefined;
+    prDetails?: {
+      title: string;
+      body: string;
+      labels: string[];
+      reviewers?: string[] | undefined;
+    } | undefined;
+  }>;
+  readonly reviewCode: ai.Tool<{
+    code: string;
+    language: "other" | "python" | "rust" | "go" | "java" | "typescript" | "javascript";
+    context?: string | undefined;
+    projectConventions?: string | undefined;
+    focusAreas?: ("security" | "performance" | "maintainability" | "testing")[] | undefined;
+  }, {
+    summary: {
+      overallScore: number;
+      recommendation: "approve" | "request-changes" | "needs-discussion";
+      reviewerConfidence: number;
+    };
+    categories: {
+      security: {
+        score: number;
+        issues: {
+          severity: "error" | "warning" | "info" | "critical";
+          message: string;
+          line?: number | undefined;
+          suggestion?: string | undefined;
+        }[];
+      };
+      performance: {
+        score: number;
+        issues: {
+          severity: "error" | "warning" | "info";
+          message: string;
+          line?: number | undefined;
+          suggestion?: string | undefined;
+        }[];
+      };
+      maintainability: {
+        score: number;
+        issues: {
+          severity: "error" | "warning" | "info";
+          message: string;
+          line?: number | undefined;
+          suggestion?: string | undefined;
+        }[];
+      };
+      testCoverage: {
+        score: number;
+        missingTests: string[];
+      };
+    };
+    antiPatterns: {
+      name: string;
+      location: string;
+      description: string;
+      suggestedFix: string;
+    }[];
+    positives: string[];
+  }>;
+  readonly processCodeReview: ai.Tool<{
+    feedback: string;
+    originalCode: string;
+    reviewerId?: string | undefined;
+  }, {
+    reviewId: string;
+    allAddressed: boolean;
+    feedbackItems: {
+      id: string;
+      type: "question" | "suggestion" | "bug" | "nitpick" | "praise";
+      severity: "critical" | "minor" | "major" | "trivial";
+      comment: string;
+      file?: string | undefined;
+      line?: number | undefined;
+      response?: {
+        action: "rejected" | "accepted" | "discussed" | "deferred";
+        explanation: string;
+        implementation?: string | undefined;
+      } | undefined;
+    }[];
+    summary: {
+      totalItems: number;
+      addressed: number;
+      deferred: number;
+      rejected: number;
+    };
+    followUpQuestions: string[];
+    updatedCode?: string | undefined;
+  }>;
+  readonly detectAntiPatterns: ai.Tool<{
+    code: string;
+    filePath: string;
+    language: "other" | "python" | "rust" | "go" | "java" | "typescript" | "javascript";
+    strictMode: boolean;
+  }, {
+    detected: boolean;
+    patterns: {
+      name: string;
+      severity: "moderate" | "minor" | "severe";
+      location: {
+        file: string;
+        line?: number | undefined;
+        snippet?: string | undefined;
+      };
+      description: string;
+      why: string;
+      fix: string;
+      category: "security" | "hardcoding" | "error-swallowing" | "magic-numbers" | "god-object" | "over-engineering" | "premature-optimization" | "copy-paste" | "other";
+    }[];
+    score: number;
+  }>;
+  readonly executePlan: ai.Tool<{
+    plan: string;
+    currentStep: number;
+    previousResults?: string | undefined;
+  }, {
+    planId: string;
+    currentStep: number;
+    totalSteps: number;
+    status: "completed" | "failed" | "in-progress" | "checkpoint" | "blocked";
+    executedSteps: {
+      stepNumber: number;
+      title: string;
+      status: "completed" | "failed" | "skipped";
+      output?: string | undefined;
+      verificationResult?: string | undefined;
+      duration?: number | undefined;
+    }[];
+    nextAction: string;
+    checkpoint?: {
+      reason: string;
+      question: string;
+      options: string[];
+    } | undefined;
+    blockers?: string[] | undefined;
+  }>;
+  readonly dispatchAgents: ai.Tool<{
+    task: string;
+    availableAgents: string[];
+    constraints?: string | undefined;
+  }, {
+    taskDecomposition: {
+      taskId: string;
+      description: string;
+      dependencies: string[];
+      estimatedDuration: string;
+      agentType: "test" | "implement" | "brainstorm" | "plan" | "review" | "document";
+    }[];
+    parallelGroups: {
+      groupId: string;
+      tasks: string[];
+      completionCondition: "any" | "all" | "majority";
+    }[];
+    executionOrder: string[];
+    coordinationStrategy: "fork-join" | "pipeline" | "scatter-gather" | "choreography";
+    mergeStrategy: string;
+  }>;
+  readonly runSubagentDev: ai.Tool<{
+    objective: string;
+    qualityGates: string[];
+    iteration: number;
+  }, {
+    phase: "complete" | "iteration" | "setup" | "quality-gate" | "integration";
+    status: "success" | "running" | "failed" | "pending";
+    iteration: {
+      number: number;
+      objective: string;
+      agentAssignments: {
+        agentId: string;
+        role: string;
+        task: string;
+        status: "running" | "completed" | "failed" | "pending";
+      }[];
+    };
+    qualityGates: {
+      name: string;
+      criteria: string;
+      passed?: boolean | undefined;
+      blockers?: string[] | undefined;
+    }[];
+    artifacts: {
+      type: "code" | "test" | "documentation" | "config";
+      path: string;
+      status: "created" | "modified" | "verified";
+    }[];
+    nextIteration?: string | undefined;
+  }>;
+  readonly systematicDebug: ai.Tool<{
+    symptom: string;
+    context: string;
+    recentChanges?: string[] | undefined;
+    failingCode?: string | undefined;
+  }, {
+    phase: "implementation" | "investigation" | "pattern-analysis" | "hypothesis-testing";
+    investigation: {
+      errorMessages: string[];
+      reproductionSteps: string[];
+      recentChanges: string[];
+      dataFlowTrace: string;
+      failurePoint: string;
+      rootCauseHypothesis: string;
+    };
+    confidence: number;
+    redFlags: string[];
+    patternAnalysis?: {
+      workingCodeExamples: string[];
+      differences: string[];
+      missingDependencies: string[];
+    } | undefined;
+    hypothesis?: {
+      statement: string;
+      testPlan: string;
+      iterations: number;
+      result?: "rejected" | "confirmed" | "inconclusive" | undefined;
+    } | undefined;
+    fix?: {
+      testCase: string;
+      implementation: string;
+      verification: string;
+    } | undefined;
+  }>;
+  readonly traceRootCause: ai.Tool<{
+    symptom: string;
+    systemLayers: string[];
+    codeContext?: string | undefined;
+  }, {
+    symptom: string;
+    traceSteps: {
+      layer: string;
+      component: string;
+      finding: string;
+      isRootCause: boolean;
+    }[];
+    rootCause: {
+      location: string;
+      description: string;
+      category: "other" | "logic-error" | "data-corruption" | "race-condition" | "missing-validation" | "configuration" | "dependency" | "resource-exhaustion";
+    };
+    contributingFactors: string[];
+    preventionRecommendations: string[];
+  }>;
+  readonly analyzeDefenseInDepth: ai.Tool<{
+    component: string;
+    code: string;
+    threatModel?: string | undefined;
+  }, {
+    layers: {
+      name: string;
+      type: "input-validation" | "authentication" | "authorization" | "encryption" | "logging" | "rate-limiting" | "error-handling" | "backup";
+      status: "present" | "missing" | "partial";
+      strength: "strong" | "adequate" | "weak";
+      recommendations: string[];
+    }[];
+    overallScore: number;
+    criticalGaps: string[];
+    redundancyAnalysis: {
+      hasRedundancy: boolean;
+      singlePointsOfFailure: string[];
+    };
+    gaps: {
+      name: string;
+      severity: "critical" | "low" | "medium" | "high";
+      recommendation: string;
+    }[];
+    recommendations: string[];
+  }>;
+  readonly analyzeAsyncPatterns: ai.Tool<{
+    code: string;
+    framework: "other" | "vitest" | "jest" | "playwright" | "cypress";
+  }, {
+    asyncOperations: {
+      description: string;
+      type: "network" | "timer" | "animation" | "state-change" | "dom-update" | "file-io";
+      waitStrategy: "promise" | "polling" | "event-listener" | "callback" | "observable";
+      condition: string;
+      timeout: number;
+      fallback: string;
+    }[];
+    raceConditions: {
+      description: string;
+      location: string;
+      fix: string;
+    }[];
+    antiPatterns: {
+      pattern: string;
+      location: string;
+      betterApproach: string;
+    }[];
+    recommendations: string[];
+  }>;
+  readonly runTDDCycle: ai.Tool<{
+    feature: string;
+    testFramework: "vitest" | "jest" | "mocha" | "playwright";
+    targetPath: string;
+    iteration: number;
+    existingTests?: string | undefined;
+    previousResult?: string | undefined;
+  }, {
+    phase: "refactor" | "write-test" | "run-test" | "implement" | "complete";
+    iteration: number;
+    nextAction: string;
+    confidence: number;
+    testFile?: {
+      path: string;
+      content: string;
+      description: string;
+    } | undefined;
+    implementation?: {
+      path: string;
+      content: string;
+      description: string;
+    } | undefined;
+    testResult?: {
+      passed: boolean;
+      output: string;
+      failureReason?: string | undefined;
+    } | undefined;
+  }>;
+  readonly refineRequirements: ai.Tool<{
+    rawRequest: string;
+    projectContext?: string | undefined;
+    existingCode?: string | undefined;
+  }, {
+    analysis: {
+      ambiguityScore: number;
+      missingContext: string[];
+      assumptions: string[];
+    };
+    clarifyingQuestions: {
+      question: string;
+      priority: "critical" | "important" | "nice-to-have";
+      context: string;
+    }[];
+    edgeCases: {
+      scenario: string;
+      risk: "low" | "medium" | "high";
+      mitigation?: string | undefined;
+    }[];
+    approaches: {
+      name: string;
+      description: string;
+      pros: string[];
+      cons: string[];
+      estimatedComplexity: "simple" | "moderate" | "complex";
+      techStackRecommendation?: string | undefined;
+    }[];
+  }>;
+  readonly consultArchitect: ai.Tool<{
+    featureRequest: string;
+    currentContext: string;
+    constraints?: string[] | undefined;
+    existingCode?: string | undefined;
+  }, {
+    summary: string;
+    riskAnalysis: {
+      risk: string;
+      severity: "critical" | "low" | "medium" | "high";
+      mitigation: string;
+    }[];
+    dependencies: {
+      name: string;
+      type: "file" | "package" | "service" | "api" | "database";
+      status: "exists" | "needs-creation" | "needs-modification";
+    }[];
+    steps: {
+      order: number;
+      title: string;
+      filePaths: string[];
+      actionType: "create" | "modify" | "delete" | "refactor" | "test" | "configure";
+      description: string;
+      verificationCmd: string;
+      blockedBy?: number[] | undefined;
+    }[];
+    rollbackPlan?: string | undefined;
+  }>;
+  readonly reviewDesign: ai.Tool<{
+    proposedChanges: string;
+    conventions: string;
+    existingArchitecture?: string | undefined;
+    affectedAreas?: string[] | undefined;
+  }, {
+    adheresToConventions: boolean;
+    conventionViolations: {
+      convention: string;
+      violation: string;
+      severity: "moderate" | "minor" | "severe";
+      suggestion: string;
+    }[];
+    architecturalConcerns: {
+      concern: string;
+      impact: "low" | "medium" | "high";
+      recommendation: string;
+    }[];
+    compatibility: {
+      backwardsCompatible: boolean;
+      breakingChanges: string[];
+      migrationRequired: boolean;
+      migrationSteps?: string[] | undefined;
+    };
+    recommendations: string[];
+    approval: "approved" | "approved-with-changes" | "rejected";
+  }>;
+};
+//#endregion
+export { systemPrompts as $, writeSkill as A, SkillWriteOutput as At, FINISHING_BRANCH_SYSTEM_PROMPT as B, WorktreeOutput as Bt, runSubagentDev as C, PlanOutputSchema as Ct, testSkill as D, SkillShareOutputSchema as Dt, systematicDebug as E, SkillShareOutput as Et, CONDITION_BASED_WAITING_SYSTEM_PROMPT as F, SuperpowersIntroOutputSchema as Ft, SHARING_SKILLS_SYSTEM_PROMPT as G, PLANNER_SYSTEM_PROMPT as H, DEFENSE_IN_DEPTH_SYSTEM_PROMPT as I, SystematicDebuggingOutput as It, SystemPromptKey as J, SUBAGENT_DRIVEN_DEV_SYSTEM_PROMPT as K, DESIGN_REVIEW_SYSTEM_PROMPT as L, SystematicDebuggingOutputSchema as Lt, BRAINSTORM_SYSTEM_PROMPT as M, SubagentDevOutput as Mt, CODE_REVIEW_SYSTEM_PROMPT as N, SubagentDevOutputSchema as Nt, traceRootCause as O, SkillTestOutput as Ot, COMMIT_ANALYSIS_SYSTEM_PROMPT as P, SuperpowersIntroOutput as Pt, WRITING_SKILLS_SYSTEM_PROMPT as Q, DISPATCHING_AGENTS_SYSTEM_PROMPT as R, TDDOutput as Rt, reviewDesign as S, PlanOutput as St, shareSkill as T, RootCauseTracingOutputSchema as Tt, RECEIVING_CODE_REVIEW_SYSTEM_PROMPT as U, GIT_WORKTREE_SYSTEM_PROMPT as V, WorktreeOutputSchema as Vt, ROOT_CAUSE_TRACING_SYSTEM_PROMPT as W, TESTING_SKILLS_SYSTEM_PROMPT as X, TDD_SYSTEM_PROMPT as Y, USING_SUPERPOWERS_SYSTEM_PROMPT as Z, planningTools as _, DefenseInDepthOutputSchema as _t, codeReviewTools as a, AsyncPatternsOutputSchema as at, refineRequirements as b, PlanExecutionOutput as bt, detectAntiPatterns as c, BranchFinishOutput as ct, finishBranch as d, CodeReviewOutputSchema as dt, AgentDispatchOutput as et, gitTools as f, CodeReviewResponseOutput as ft, metaTools as g, DefenseInDepthOutput as gt, manageWorktree as h, CommitAnalysisOutputSchema as ht, analyzeDefenseInDepth as i, AsyncPatternsOutput as it, ANTI_PATTERN_SYSTEM_PROMPT as j, SkillWriteOutputSchema as jt, workflowTools as k, SkillTestOutputSchema as kt, dispatchAgents as l, BranchFinishOutputSchema as lt, introduceSuperpowers as m, CommitAnalysisOutput as mt, analyzeAsyncPatterns as n, AntiPatternOutput as nt, consultArchitect as o, BrainstormOutput as ot, initSuperpowers as p, CodeReviewResponseOutputSchema as pt, SYSTEMATIC_DEBUGGING_SYSTEM_PROMPT as q, analyzeCommit as r, AntiPatternOutputSchema as rt, debuggingTools as s, BrainstormOutputSchema as st, allSuperpowerTools as t, AgentDispatchOutputSchema as tt, executePlan as u, CodeReviewOutput as ut, processCodeReview as v, DesignReviewOutput as vt, runTDDCycle as w, RootCauseTracingOutput as wt, reviewCode as x, PlanExecutionOutputSchema as xt, qualityTools as y, DesignReviewOutputSchema as yt, EXECUTING_PLANS_SYSTEM_PROMPT as z, TDDOutputSchema as zt };
+//# sourceMappingURL=index-BGgMn_Ev.d.mts.map